Algoritmos

ALGORITMO Y ESTRUCTURA DE DATOS I

1

UNIVERSIDAD TECNOLÓGICA DEL PERÚ

Vicerrectorado de Investigación

ALGORITMOS Y ESTRUCTURA DE DATOS I

TINS

INGENIERÍA INDUSTRIAL, INGENIERÍA DE SISTEMAS

TEXTOS DE INSTRUCCIÓN (TINS) / UTP

Lima - Perú


2

© ALGORITMOS Y ESTRUCTURA DE DATOS I Desarrollo y Edición: Vicerrectorado de Investigación Elaboración del TINS: Ing. Carlos Parra Terrazos

Diseño y Diagramación: Julia Saldaña Balandra

Soporte académico: Instituto de Investigación

Producción: Imprenta Grupo IDAT

Queda prohibida cualquier forma de reproducción, venta, comunicación pública y transformación de esta obra.


3

“El presente material contiene una compilación de contenidos de obras Algoritmos y Estructura de Datos publicadas lícitamente, resúmenes de los temas a cargo del profesor; constituye un material auxiliar de enseñanza para ser empleado en el desarrollo de las clases en nuestra institución. Éste material es de uso exclusivo de los alumnos y docentes de la Universidad Tecnológica del Perú, preparado para fines didácticos en aplicación del Artículo 41 inc. C y el Art. 43 inc. A., del Decreto Legislativo 822, Ley sobre Derechos de Autor”.


4


5

PRESENTACIÓN

El presente texto elaborado en el marco de desarrollo de la Ingeniería, es

un material de ayuda instruccional, para las carreras de Ingeniería de: Sistemas, Industrial, Electrónica, Mecatrónica y Telecomunicaciones, para la Asignatura de Algoritmos y Estructura de Datos.

Plasma la iniciativa institucional de innovación de la

enseñanza-aprendizaje educativo universitario, que en acelerada continuidad promueve la producción de materiales educativos, actualizados en concordancia a las exigencias de estos tiempos.

Esta primera edición apropiadamente recopilada, de diversas fuentes

bibliográficas, de uso frecuente en la enseñanza de Algoritmos, está ordenada en función del syllabus de la Asignatura, arriba mencionada.

La conformación del texto ha sido posible gracias al esfuerzo y dedicación académica del Profesor Ing. Carlos Parra Terrazos; contiene seis capítulos, cuyas descripciones genéricas son como sigue:

Capítulo 1: Conceptos fundamentales. Antes de introducirnos en el

contenido de este manual será necesario conocer los conceptos básicos que nos ayudaran a tener un panorama general y entender con mayor facilidad los siguientes capítulos. Aprenderemos a diferenciar un algoritmo de un programa y de un lenguaje de programación, así como conocer la importancia de los tipos de datos y los datos para la programación.

Capítulo 2: Estructura general de un programa. En este capítulo

encontraremos el concepto de Programa, las partes que lo conforman e introduciremos al estudiante en el proceso de la programación a partir de la presentación de programas en lenguaje C. También se detallarán las instrucciones y sus tipos.

Capítulo 3: Estructuras de control. Durante un programa existen

acciones que cambian el flujo de control de un programa estas estructuras básicas de acuerdo a la programación estructurada son: La estructura secuencial, la estructura selectiva o condicional y la estructura repetitiva o de iteración; necesarias para poder diseñar algoritmos de cualquier grado de dificultad.


6

Capítulo 4: Subprogramación. Modularidad es un concepto que tiene aplicaciones en la ciencia de la computación, particularmente para permitir manejar la complejidad de los programas a partir del concepto de “divide y vencerás” cuya implementación se lleva a cabo mediante el diseño descendente y refinamientos sucesivos así como su implementación mediante las funciones y procedimientos.

Capítulo 5: Recursividad. Este capítulo nos detallará la recursividad en

Algoritmos, esta herramienta es muy útil en la solución de problemas; ya que transforma a éstos en problemas más sencillos a partir de la llamada de los programas, a si mismos.

Capítulo 6: Datos estructurados. Los datos se clasifican en datos simples

y datos estructurados o estructuras de datos que son una forma de organizar un conjunto de datos para poder manipularlos con mayor facilidad, como si se tratase de uno solo. En esta parte se conocerán los arreglos, los registros y las cadenas de caracteres.

Finalmente, al cierre de estas líneas, el agradecimiento institucional al

profesor Ing. Carlos Parra Terrazos por su contribución a la elaboración del presente texto.

Vicerrectorado de Investigación


7

ÍNDICE

CAPÍTULO I: CONCEPTOS FUNDAMENTALES 1.1 CONCEPTO DE ALGORITMO, EL SOFTWARE, LENGUAJES DE

PROGRAMACION.............................................................................. 11 1.2 RESOLUCIÓN DE PROBLEMAS CON COMPUTADORA -

FASES .................................................................................................. 13 1.3 HERRAMIENTAS DE PROGRAMACIÓN ....................................... 16 1.4 TIPOS DE DATOS............................................................................... 20 1.5 CONSTANTES, VARIABLES, IDENTIFICADORES,

EXPRESIONES, FUNCIONES ........................................................... 23 1.6 PARTE PRÁCTICA............................................................................. 27

PROBLEMAS PROPUESTOS ............................................................ 27 LABORATORIO Nº 1......................................................................... 31

CAPÍTULO II: ESTRUCTURA GENERAL DE UN PROGRAMA

2.1 ESTRUCTURA DE UN PROGRAMA EN C. .................................... 40 2.2 ESTRUCTURA DE ALGORITMO..................................................... 44 2.3 CONTADORES, ACUMULADORES. ............................................... 44 2.4 PARTE PRÁCTICA............................................................................. 47

PROBLEMAS PROPUESTOS ............................................................ 47 LABORATORIO Nº 2.......................................................................... 49

CAPÍTULO III: ESTRUCTURAS DE CONTROL

3.1 PROGRAMACIÓN ESTRUCTURADA............................................. 59 3.2 ESTRUCTURA DE CONTROL – TIPOS........................................... 59 3.3 PARTE PRÁCTICA............................................................................. 74

PROBLEMAS PROPUESTOS ............................................................ 74 LABORATORIO Nº 3.......................................................................... 78

CAPÍTULO IV: SUBPROGRAMACIÒN

4.1 PROGRAMACIÓN MODULAR......................................................... 83 4.2 SUBPROGRAMAS – TIPOS............................................................... 85

4.2.1 VARIABLES GLOBALES Y LOCALES. ............................ 87 4.2.2 FUNCIONES, PASO DE PARÁMETROS............................ 89

4.3 PARTE PRÁCTICA............................................................................. 94 PROBLEMAS PROPUESTOS ............................................................ 94 LABORATORIO Nº 4.......................................................................... 95


8

CAPÍTULO V: RECURSIVIDAD 5.1 RECURSIVIDAD............................................................................... 103 5.2 CARACTERÍSTICAS........................................................................ 103 5.3 VENTAJAS Y DESVENTAJAS ....................................................... 104 5.4 PELIGROS EN LA RECURSIVIDAD.............................................. 104 5.5 TIPOS DE ALGORITMOS RECURSIVOS...................................... 105 5.6 VERIFICACIÓN DE FUNCIONES RECURSIVAS ........................ 107 5.7 LA PILA DE RECURSIÓN ............................................................... 108 5.8 LLAMADA A UNA FUNCIÓN RECURSIVA ................................ 108 5.9 PARTE PRÁCTICA........................................................................... 109

PROBLEMAS PROPUESTOS .......................................................... 109 LABORATORIO Nº 5........................................................................ 110

CAPÍTULO VI: DATOS ESTRUCTURADOS

6.1 TIPOS ................................................................................................. 113 6.2 ARREGLOS UNIDIMENSIONALES, DECLARACION Y

ACCESO............................................................................................. 114 6.3 ARREGLOS BIDIMENSIONALES, DECLARACION Y ACCESO117 6.4 REGISTROS....................................................................................... 122

6.4.1 CONCEPTO ......................................................................... 122 6.4.2 DECLARACION Y ACCESO ............................................. 122 6.4.3 ARREGLO DE REGISTROS .............................................. 124

6.5 CADENAS DE CARACTÉRES ........................................................ 125 6.6 PARTE PRÁCTICA........................................................................... 129

PROBLEMAS PROPUESTOS: ......................................................... 129 LABORATORIO Nº 6........................................................................ 130

BIBLIOGRAFÍA .......................................................................................... 1389


9

DISTRIBUCIÓN TEMÁTICA

Clase N° TEMA SEMANA

1 Conceptos Fundamentales 1

2 Tipo de datos 2

3 Estructura general de un programa 3

4 Estructuras de control 4

5 Selectiva doble – Selectiva múltiple 5

6 Selectiva de control (SEGÚN – SEA) 6

7 Iterativa (REPETIR – DESDE) 7

8 Iterativa (REPETIR - MIENTRAS ) 8

9 Revisión – Nivelación 9

10 E X A M E N P A R C I A L 10

11 Subprogramación 11

12 Procedimientos de paso de parámetros 12

13 Recursividad 13

14 Datos Estructurados 14


10

Clase N° TEMA SEMANA

15 Arreglos bidimensionales Declaración y acceso 15

16 Registros 16

17 Cadena de caracteres 17

18 Índices 18

19 Nivelación – Recuperación 19

20 EXAMEN FINAL 20

21 EXAMEN SUSTITUTORIO 21


11

CAPÍTULO I: CONCEPTOS FUNDAMENTALES 1.1 CONCEPTO DE ALGORITMO, EL SOFTWARE, LENGUAJES

DE PROGRAMACIÓN

a) CONCEPTOS DE ALGORITMO

• Un algoritmo es un conjunto finito de instrucciones o pasos con una secuencia lógica que sirven para ejecutar una tarea o resolver un problema.

• De un modo más formal, un algoritmo es una secuencia lógica finita de operaciones realizables, no ambiguas, cuya ejecución da una solución de un problema en un tiempo finito.

- COMPONENTES DE UN ALGORITMO

Entrada : Datos del problema a resolver. Salida : El resultado de la resolución. Procesos : Paso a seguir en la resolución.

- CARACTERÍSTICAS DE UN ALGORITMO

PRECISIÓN Solución clara sin ambigüedad.

REPETITIVIDAD Idénticos resultados en las mismas

condiciones iniciales.

FINITUD Solución en un tiempo finito.

EFICIENCIA Tiempo de ejecución.

Requerimiento de memoria.

- ALGORITMO VS LENGUAJE DE PROGRAMACIÓN

Un lenguaje de programación es tan solo un medio para expresar un algoritmo.

EJEMPLO Nº 1 Un cliente efectúa un pedido a una compañía, La compañía verifica en su banco de datos la ficha del cliente, si el cliente es solvente entonces la compañía acepta el pedido; en caso


12

contrario, rechazará el pedido. Realizar el algoritmo del ejemplo.

Los pasos del algoritmo son: 1. Inicio 2. Leer el pedido 3. Verificar la ficha del cliente 4. Si el cliente es solvente, aceptar pedido; en caso

contrario, rechazar pedido. 5. Fin

CONCEPTO DE PROGRAMA

• Un programa es una secuencia de instrucciones de la

CPU. • Cada instrucción es un conjunto de bytes. • Conjunto de instrucciones dado al ordenador para

realizar un proceso determinado.

EJEMPLO Nº 2

1. Leer un dato del teclado. 2. Guardar un dato en la memoria. 3. Ejecutar una operación sobre los datos. 4. Mostrar un dato en la pantalla.

b) CONCEPTO DE SOFTWARE

• Es la parte lógica de la computación. • Conjunto de programas que sirven para representar un

segmento de la realidad y resolver un problema. Como por ejemplo: el Office, un sistema operativo, C++, Pascal, Java, etc.

c) LENGUAJES DE PROGRAMACIÓN

Son aquellos lenguajes que se utilizan para realizar algoritmos interpretables por la computadora.

Características imprescindibles Estructura de Control.

Programación Modular (funciones).

Los principales tipos de lenguajes utilizados antes y en la actualidad son tres:


13

• Lenguaje máquina. • Lenguaje de bajo nivel (ensamblador). • Lenguajes de alto nivel: C, C++, Visual Basic, Java,

Pascal, Prolog.

1.2 RESOLUCIÓN DE PROBLEMAS CON COMPUTADORA - FASES Actualmente la resolución de problemas con computadoras facilita el trabajo del usuario, debido a la gran velocidad de esta herramienta (computadora).

El siguiente esquema nos muestra las fases de la resolución de problemas con computadora.


14

FASE Nº 01: ANÁLISIS DEL PROBLEMA

EJEMPLO Nº 3 Imprimir la hipotenusa, teniendo los lados de un triangulo rectángulo.

Variables: LADO1, LADO2 y LADO3 (tipo reales). Entradas: Valores de los lados (variable LADO1 y variable

LADO2). Salida: Valor de la hipotenusa (variable LADO3).

FASE Nº 02: DISEÑO DEL ALGORITMO


15

EJEMPLO Nº 4 Determine a los números menores que 90 y múltiplos de 9, así como su sumatoria.

FASE Nº 03: SOLUCIÓN DEL PROBLEMA POR COMPUTADORA Traducción del algoritmo al lenguaje de programación. La complejidad depende mucho del lenguaje escogido. Imprescindible: Conocimiento de la sintaxis del lenguaje.

Buenos diseños del Algoritmo + Traducción casi automática Lenguaje estructurado

FASE Nº 04: VERIFICACIÓN Y DEPURACIÓN

DefinicióndelProblema

Especificaciones de entrada

Especificaciones de salida

Imprim ir múltip los de 9

y su suma siempre y

cuando sea menor que 90

TOTAL = 0 NUM = 9

LIMITE = 90

NUM, TOTAL

Definición del problema


16

FASE Nº 05: DOCUMENTACIÓN Descripción de qué hace el programa y cómo lo hace. Documentación interna: Comentarios: líneas informativas incluidas en el código. Tarea que realiza. Datos de entrada y salida. Condiciones de error.

Codificación auto documentada.

Nombres de variables y funciones con significado. Estructura fácil de leer.

Documentación externa: Manuales, estructura y especificaciones del programa, historia de las modificaciones, etc.

FASE Nº 06: MANTENIMIENTO

1.3 HERRAMIENTAS DE PROGRAMACIÓN Son aquellas que permiten realizar aplicativos, programas, rutinas, utilitarios y sistemas para que la parte física del computador u ordenador, funcione y pueda producir resultados.


17

Un ejemplo claro son los Lenguajes de Programación, las librerías, los utilitarios, los generadores de reportes, pantallas, etc.

Las herramientas más usadas para desarrollar algoritmos son:

• Lenguaje natural. • Organigramas. • Diagramas Nassi – Shneiderman (N - S). • Pseudocódigo. • Otros

LENGUAJE NATURAL: Es un lenguaje utilizado para describir los pasos de cómo realizamos algo, de una forma sencilla. • Ventajas: Facilidad de comprensión. • Inconvenientes:

o El lenguaje natural no es universal, un algoritmo de lenguaje natural en inglés, por ejemplo, sería completamente inútil para los hispanohablantes.

o El lenguaje natural es ambiguo y, por tanto, susceptible de errores.

o El lenguaje natural es demasiado amplio, lo que para una persona puede ser una instrucción sencilla puede no serlo para otra y desde luego no lo será para una computadora.

EJEMPLO Nº 5 • El algoritmo para encontrar las raíces de una ecuación de

segundo grado podría describirse así:

x = (-b + √b2 – 4ac) / (2a)

1. Definir los coeficientes de la ecuación de segundo grado: a, b y c.

2. Determinar el valor del discriminante: b2 – 4ac. 3. Si el discriminante es cero sólo hay una solución: -b/ (2a).

ORGANIGRAMAS: • Los organigramas o diagramas de flujo permiten describir los

algoritmos de forma grafica.


18

• Utilizan una serie de bloques que indican distintas circunstancias y flechas que muestran bajo qué condiciones se pasa de un bloque a otro.


19

DIAGRAMA DE FLUJO VS PSEUDOCÓDIGO:

Estructuras Pseudocódigo Diagrama de flujo

Inicio Begin

Entrada y salida de Datos

Read x Write x

Sentencia Calcular x = y+3

Secuencia de sentencias

Se escribe en líneas separadas Calcular x = y+3 Calcular z = 2*x

Selección

IF condición entonces Acción 1 ELSE Acción 2

Repetición

DO WHILE Acción 1 … … …

Fin End

Read x

Begin


20

Una vez diseñado el algoritmo y representado mediante una herramienta de programación se debe:

1.4 TIPOS DE DATOS Un dato es la expresión general que describe los objetos con

los cuales opera la computadora. Todos los datos tienen un tipo asociado con ellos. Un dato puede ser un simple carácter, tal como “b”, un valor

entero tal como “35”. El tipo de dato determina la naturaleza del conjunto de valores

que puede tomar una variable.

DATOS VS INFORMACIÓN

DDAATTOOSS VVSS IINNFFOORRMMAACCIIÓÓNN - Medidas objetivas de atributos

de entidades. - Cifras/hechos crudos (en

bruto) sin interpretar o analizar.- No son estímulos de acción.

- Resultado de haber organizado o analizado los datos de alguna manera lógica.

- Reduce la incertidumbre. - Impulsa a la acción.

Solución del Problema por Computadora

Codificación del programa

Ejecución del programa

Comprobación del programa

Solución del Problema por Computadora

Codificación del programa

Ejecución del programa

Comprobación del programa

Programafuente

Programa Objeto

Programaejecutable

Compilador(Compiler)

Montador(Linker)

Programafuente

Programa Objeto

Programaejecutable

Compilador(Compiler)

Montador(Linker)


21

EJEMPLO Nº 6

- CLASIFICACIÓN

TIPODE DATO

DATOS SIMPLES

DATOS ESTRUCTURADOS

ESTANDAR

DEFINIDOS X EL PROGRAMADOR

NUMERICO

CHARACTER

LOGICO (BOOLEAN)

REAL

ENTERO

ENUMERATIVO

SUBRANGO

ESTATICOS

DINAMICOS

ARRAYSREGISTROARCHIVO (FICHERO)

LISTA (PILA/COLA)LISTA ENLAZADA

CONJUNTO)

CADENA (STRING)

ARBOLGRAFO

TIPODE DATO

DATOS SIMPLES

DATOS ESTRUCTURADOS

ESTANDAR

DEFINIDOS X EL PROGRAMADOR

NUMERICO

CHARACTER

LOGICO (BOOLEAN)

REAL

ENTERO

ENUMERATIVO

SUBRANGO

ESTATICOS

DINAMICOS

ARRAYSREGISTROARCHIVO (FICHERO)

LISTA (PILA/COLA)LISTA ENLAZADA

CONJUNTO)

CADENA (STRING)

ARBOLGRAFO

DA TO S

35.000 Soles 1250 unidadesJosé Perez Lima 83.000 Dólares. 3800 unidades .......

PRO CE SA M IEN T O D E D AT O S

IN FO R M AC IÓ N

Cliente: José PerezSucursal: LimaCompras del mes:1250 unidades=35.000 Soles. ......

DA TO S

35.000 Soles 1250 unidadesJosé Perez Lima 83.000 Dólares. 3800 unidades .......

PRO CE SA M IEN T O D E D AT O S

IN FO R M AC IÓ N

Cliente: José PerezSucursal: LimaCompras del mes:1250 unidades=35.000 Soles. ......


22

- TIPOS DE DATOS SIMPLES

Representación Tipo Longitud de byte Rango

Carácter Char Unsigned char

1 1

-128 a 127

Enteros

Int Short int Unsigned int Long Unsigned long

2 2 2 4 4

-32768 a 32767 -32768 a 32767 0 a 65535 -2147483648 a 2147483647 0 a 4294967295

Reales Float Double Long double

4 8 10

3.4E±38 1.7E±308 3.4E-4932 a 1.1E+4932

DATOS NUMÉRICOS Permiten representar valores escalares de forma numérica, esto incluye a los números enteros y los reales. Este tipo de datos permiten realizar operaciones aritméticas

DATOS LÓGICOS Son aquellos que sólo pueden tener dos valores (cierto o falso) ya que representan el resultado de una comparación entre otros datos (numéricos o alfanuméricos).

DATOS ALFANUMÉRICOS Es una secuencia de caracteres alfanuméricos que permiten representar valores identificables de forma descriptiva, esto incluye nombres de personas, direcciones, etc. Es posible representar números como alfanuméricos, pero estos pierden su propiedad matemática, es decir no es posible hacer operaciones con ellos. Este tipo de datos se representan encerrados entre comillas.


23

¿POR QUÉ ESTUDIAR LOS DATOS?

LOS PROGRAMAS OPERAN SOBRE DATOS

ALGORITMOS +

ESTRUCTURA DE DATOS =

PROGRAMA NIKLAUS WIRTH

1.5 CONSTANTES, VARIABLES, IDENTIFICADORES, EXPRESIONES, FUNCIONES

- CONSTANTES

Constantes: Valores que durante la ejecución de un programa no cambian su valor.

Ejemplo: pi = 3.1416

- VARIABLES

Definición 1: Valores que cambiarán durante la ejecución del programa.

Definición 2: Es un espacio en la memoria de la computadora que permite almacenar temporalmente un dato durante la ejecución de

DATOS DEENTRADA

ALGORITMO

DATOS DESALIDA

DATOS DEENTRADA

ALGORITMO

DATOS DESALIDA


24

un proceso, su contenido puede cambiar durante la ejecución del programa. CLASIFICACIÓN DE LAS VARIABLES

* POR SU USO

• DE TRABAJO Variables que recibe el resultado de una operación matemática completa y que se usan normalmente dentro de un programa.

Ejemplo: Suma a + b /c

• CONTADORES Se utilizan para llevar el control del número de ocasiones en que se realiza una operación o se cumple una condición. Con los incrementos generalmente de uno en uno. Ejemplo: Cont Cont + 1

Num Num + 2

• ACUMULADORES Forma que toma una variable y que sirve para llevar la suma acumulativa de una serie de valores que se van leyendo o calculando progresivamente.

Ejemplo: Suma Suma + cant

IDENTIFICADORES Para poder reconocer una variable o una constante en la memoria de la computadora, es necesario darle un nombre con el cual


25

podamos identificarla dentro de un algoritmo, esto se llama un identificador. Ejemplo: área pi * radio ^ 2 Los identificadores son: el radio, el área y la constante es pi. EXPRESIONES Se definen como una combinación de constantes, variables, símbolos de operación, paréntesis, y nombres de funciones especiales. Una expresión consta de operandos y operadores. Ejemplo: x + (y+10)+ z/2 Las expresiones se clasifican en:

o Aritméticas o Lógicas o Carácter

EnteroEnteromóduloMod

EnteroEnteroDivisión enteraDiv

RealReal División/

Entero o realEntero o realMultiplicación*

Entero o realEntero o realResta-

Entero o realEntero o realSuma+

Entero o realEntero o realExponenciación**

Tipo resultadoTipo de operandosSignificadoOperador

EnteroEnteromóduloMod

EnteroEnteroDivisión enteraDiv

RealReal División/

Entero o realEntero o realMultiplicación*

Entero o realEntero o realResta-

Entero o realEntero o realSuma+

Entero o realEntero o realExponenciación**

Tipo resultadoTipo de operandosSignificadoOperador

26

Reglas de prioridad

Operadores de relación

Operadores lógicos

Ejemplo: • Not 4 > 5 produce un error ya que el operador no se aplica a 4 • Not (4 > 5) produce un valor verdadero.

Ejemplo: • P and Q. • P or Q.

Menor<

Distinto<>,!=Mayor o igual>=Menor o igual<=

Igual=Mayor>

SignificadoOperadorMenor<

Distinto<>,!=Mayor o igual>=Menor o igual<=

Igual=Mayor>

SignificadoOperador

disyunciónP o QOr

ConjunciónP y QAndNegaciónNot pNot

SignificadoExpresión lógicaOperador lógico

disyunciónP o QOr

ConjunciónP y QAndNegaciónNot pNot

SignificadoExpresión lógicaOperador lógico


27

FUNCIONES Las funciones pueden tener cualquier número de variables, incluso cero. Para evaluar una función sin variables se debe escribir un par de paréntesis después de su nombre (por ejemplo fun()). Las funciones sin variables pueden servir como algoritmos de cálculo que devuelven un valor real. FUNCIONES MATEMÁTICAS

1.6 PARTE PRÁCTICA

PROBLEMAS PROPUESTOS

1. Diseñar un algoritmo para cambiar la rueda de un auto. 2. Diseñar un algoritmo para preparar una torta 3. Diseñar un algoritmo para organizar una fiesta 4. Diseñar un algoritmo para organizar un paseo 5. Diseñar un algoritmo para organizar un concierto 6. Realizar el algoritmo para determinar el mayor de tres

números enteros

TruncamientoTrunc(x)Raíz cuadradaSqrt(x)

CuadradoSqr(x)SenoSin(x)

RedondeoRound(x)Log decimalLog10(x)

Log neperianoLn(x)ExponencialExp(x)

CosenoCos(x)Tangente inversaArctan(x)

AbsolutoAbs(x)DescripciónFunción

TruncamientoTrunc(x)Raíz cuadradaSqrt(x)

CuadradoSqr(x)SenoSin(x)

RedondeoRound(x)Log decimalLog10(x)

Log neperianoLn(x)ExponencialExp(x)

CosenoCos(x)Tangente inversaArctan(x)

AbsolutoAbs(x)DescripciónFunción


28

7. Realizar el algoritmo para calcular la superficie de un círculo. 8. Realizar el algoritmo para calcular el perímetro y la superficie

de un rectángulo dadas las base y la altura del mismo. 9. Escribir un algoritmo que lea un nombre de una marca de

automóviles seguida del nombre de su modelo e informe del modelo seguido del nombre.

10. Realizar el algoritmo para determinar la hipotenusa de un triángulo rectángulo conocidas las longitudes de los catetos.

11. Se desea un algoritmo para convertir metros a pies y pulgadas.

(1 metro = 39.37 Pulgadas, 1 pie = 12 pulgadas). 12. Escribir un algoritmo que permita calcular el área de un

triangulo conocidos sus tres lados. 13. Diseñar un programa para calcular el área y el perímetro de un

triangulo rectángulo conociendo la longitud de sus catetos. Si a, b y c representan los tres lados de un triangulo, entonces la formula que determina su área será:

A = [p (p-a) (p-b) (p-c)]1/2 Donde p representa el semiperímetro del triangulo que se calcula con la formula: p = (a+b+c)/2

14. Una empresa desea transmitir datos mediante el teléfono pero en forma cifrada ante la posibilidad de que los teléfonos estén intervenidos. La empresa le ha solicitado que escriba un programa que cifre sus datos que consisten en números enteros de cuatro dígitos. El cifrado debe hacerse de la siguiente manera: Intercambiar el primer digito con el tercero, y el segundo con el cuarto. A continuación imprimir el entero cifrado.

15. Escribir un programa que lea un numero de 4 cifras y o invierta. Así, por ejemplo, si el número leído es 2345 se debe convertir en 5432.

16. Diseñar un programa para convertir una cantidad de nuevos soles a billetes enteros de S/.100, S/. 50, S/.20, S/.10, S/.5 y monedas de S/.1. Suponga que la cantidad es mayor que S/.1000. Por ejemplo: en S/.1289 hay 12 billetes de S/.100, 1 billete de S/.50, 1 billete de S/.20, 1 billete de S/.10, 1 moneda de S/.5 y 4 monedas de S/. 1.


29

17. Diseñar un programa para convertir una cantidad entera de segundos a horas, minutos y segundos. Suponga que la cantidad de segundos es mayor que 3600 sg.

18. Diseñar un programa para convertir grados Centígrados (C) a grados Fahrenheit (F). Considere que: F = 9C/5 + 32.

19. Diseñar un programa para convertir grados sexagesimales (S) a grados centesimales (C) y radianes (R). Considere que: S/180 = C/200 = R/π.

20. Escriba un programa que permita calcular el área de un triangulo conocido sus tres lados.

21. Escriba un programa que permita leer una medida en pies y la convierta en centímetros, metros, pulgadas y yardas. Considere los siguientes factores de conversión. 1 pie = 12 pulgadas 1 yarda = 3 pies 1 pulgada = 2.54 centímetros 1 metro = 100 centímetros

22. Escriba un programa que permita lea una temperatura en grados Centígrados(C) y la convierta en sus equivalentes en grados Fahrenheit (F), grados kelvin (K) y grados Rankine (R). Utilice las siguientes formulas: F = 9/5 C + 32 K = C + 273 R = C + 460

23. Un curso se evalúa de la siguiente forma: se toman 5 prácticas, un examen parcial y un examen final. El promedio final se calcula con la siguiente formulas: PF = (3PP + 2EP + 3EF)/7 Donde: PF = promedio final

PP = promedio de la 5 practicas EP = examen parcial EF = examen final

Escriba un programa que calcule el promedio final del curso.


30

24. Escriba un programa para calcular el monto a pagar por un artículo. Los datos de entrada son: el precio de venta y el número de unidades adquiridas. Considere un descuento fijo de 20% y 19% de IGV. El programa deberá mostrar el monto del descuento y el monto a pagar.

25. Escriba un programa para efectuar repartos proporcionales de una suma de dinero a 5 personas en funciones de sus edades. El programa deberá solicitar la suma de dinero y las edades de las 5 personas. El monto que le corresponde a cada persona se calcula con la formula:

edadP×montoTMontoP =edadT

Donde: montoT = monto del dinero a repartir montoP = monto correspondiente a una persona edadP = edad de la persona edadP = suma total de edades

Imprimir el monto de dinero correspondiente a cada persona. 26. Escribir un programa para determinar el interés generado por

un capital C que representa un préstamo a una taza de interés anual del T% durante N años. Mostrar el monto total obtenido al cabo de los N años y el interés generado I. Use las siguientes formulas: M = C (1+ T/100)N I = M – C Donde: M = Monto total obtenido al cabo de los N años C = Capital prestado I = Interés generado al cabo de los N años N = Numero de años

27. Escriba un programa que ingrese un valor de a y b y calcule los valores de c y d de acuerdo con las siguientes formulas:

c = (4a4 + 3ab +b2) / (a2 + b2) ; d= (3c2 + a +b) / 4


31

LABORATORIO Nº 1

Este laboratorio tiene como objetivo que el alumno aprenda a convertir el pseudo código a código TURBO C++ para su ejecución. PASOS A SEGUIR:

Paso 1: Ingresar a inicio – programas – Turbo C++ 4.5. o en otro compilador de C que le indique el docente Paso 2: Hacer click en programa Turbo C++

Paso 3: Una vez abierto el programa haga click en File y en New, generando una nueva hoja de trabajo.


32

Paso 4: Para guardar la hoja se hace click en File – Save as

Paso 5: Al hacer click en Save As saldrá una pantalla en donde se colocara el nombre del archivo y nos indica la ruta en donde va a ser guardada el archivo.

33

Paso 6: Una vez colocada el nombre y la ruta presionar OK. Paso 7: Una vez guardada la hoja proceder a transcribir el siguiente código de programa.

#include <iostream.h> #include <conio.h> Int main( ) { float base, altura, area, perímetro; cout<<"Base: "; cin>>base; cout<<"Altura: "; cin>>altura; área = base * altura ; perímetro = 2 * (base + altura) ; cout<<"El Area es :" << area << endl ; cout<<"El perímetro es : " << perímetro << endl; getch(); return 0; }


34

Paso 8: Para compilar el programa hacer click en Project - Compile Otra manera de compilar es presionar en el teclado Alt + F9.


35

Paso 9: Si no hubiera error aparecerá un cuadro con un visto indicando OK, que indica Status: Success, quiere decir que no hay error de caso contrario aparecerá Status: There are errors, indicando la posición en donde esta el error.

Paso 10: Ejecutar el programa se realiza haciendo click en Debug – Run.

Otra manera de ejecutar o correr el programa es presionando las teclas Control + F9.


36

Paso 11: Mostrará el programa ejecutando los comandos escritos:


37

CAPÍTULO II: ESTRUCTURA GENERAL DE UN PROGRAMA

CONCEPTO DE PROGRAMA

Es un conjunto de instrucciones, ordenes dadas a la máquina que producirán la ejecución de una determinada tarea, en esencia es un medio para seguir un fin.

DESARROLLO DE UN PROGRAMA 1. Definición y Análisis del problema 2. Diseño de algoritmos:

Diagrama de flujo. Diagrama de N-S. Pseudocódigo. Otros

3. Codificación del Programa. 4. Depuración y verificación del Programa. 5. Documentación. 6. Mantenimiento.

PARTES CONSTITUTIVAS DE UN PROGRAMA El programador debe establecer el conjunto de especificaciones que debe contener el programa: entrada, salida y algoritmos de resolución.

INSTRUCCIONES Y TIPOS DE INSTRUCCIONES CONSISTE EN DEFINIR:

• LAS ACCIONES O INSTRUCCIONES, se deben escribir y posteriormente almacenar en memoria en el mismo orden en que han de ejecutarse; es decir en secuencia.

ENTRADA PROGRAMAAlgoritmo de resolución

SALIDAENTRADA PROGRAMAAlgoritmo de resolución

SALIDA


38

• Un programa es lineal si se ejecutan secuencialmente, sin

bifurcaciones decisión y comparación

• En el caso de algoritmos las instrucciones se suelen conocer como acciones y se tendría:

• Y es no lineal cuando se interrumpe la secuencia mediante instrucciones de bifurcación:

TIPOS DE INSTRUCCIÓN 1. Instrucciones de inicio / fin 2. Instrucciones de asignación 3. Instrucciones de lectura 4. Instrucciones de escritura 5. Instrucciones de bifurcación 6. Fin

- Instrucciones de asignación

A 80 la variable A toma el valor de 80 ¿Cuál será el valor que tomara la variable C tras la ejecución de las siguientes instrucciones?

IN S T R U C C IÓ N 1IN S T R U C C IÓ N 2

.

.

.IN S T R U C C IÓ N N

Acción 1Acción 2

.Acción N

Acción 1Acción 2

.Accion xAcción N

.


39

A 12 A contiene 12

B A B contiene 12

C B C contiene 12

Antes de la ejecución de las tres instrucciones A, B, C son

indeterminados.

¿Cuál es el valor de la variable AUX al ejecutarse la instrucción 5?

1. A 10

2. B 20

3. AUX 10

4. A B

5. B AUX;

En la instrucción 1, A toma el toma el valor de 10…

- Instrucciones de lectura de datos (entrada) ¿Cuál será el significado de las siguientes instrucciones?

a) Read numero, horas, tasa

número 12325 horas 32 tasa 1200

b) Read A, B, C

A 100 B 200 C 300

- Instrucciones de escritura de resultados (salida)

- A 100

- B 200

- C 300

Write A, B, C

Esta instrucción lee datos de

un dispositivos de entrada

Esta instrucción se escribe en

un dispositivo de salida


40

2.1 ESTRUCTURA DE UN PROGRAMA EN C. - Los programas en C pueden constar de uno o varios archivos.

- Cada archivo puede contener uno o varios espacios de

nombres.

- Un espacio de nombres puede contener tipos como clases,

estructuras, interfaces, enumeraciones y delegados, además

de otros espacios de nombres. A continuación, se muestra el

esqueleto de un programa en C que contiene todos estos

elementos.

41

EJEMPLO Nº 7 /* Comentarios de un párrafo completo comprendidos entre

/*.....*/, Sirven para aclarar el programa o una parte del programa */ // Comentarios de 1 sola línea. // Zona de ficheros de cabecera de las librerías.

Ejemplo:

/* El primer programa en C */

#include <stdio.h>

int main( void )

{ printf(“Bienvenido a C!" );

return 0; /* indica que el programa terminó con éxito */

}

EJEMPLO Nº 8

/* Programa de suma */

#include <stdio.h>

int main() /* la función main inicia la ejecución del programa */

{

int entero1; /* primer número introducido por el usuario */

int entero2; /* segundo número introducido por el usuario */

int suma; /* variable en la cual se almacena la suma */

printf( "Introduzca el primer entero\n" ); /* indicador */

scanf( "%d", &entero1 ); /* lee un entero */

printf( "Introduzca el segundo entero\n" ); /* indicador */

scanf( "%d", &entero2 ); /* lee un entero */

suma = entero1 + entero2; /* asigna el total a suma */

printf( "La suma es %d\n", suma ); /* imprime la suma */

return 0; /* indica que el programa terminó con éxito */

} /* fin de la función main */


42

• DEFINICIONES DE ARCHIVOS DE CABECERA DE LAS LIBRERÍAS

• Un comentario dentro del programa se utilizan para explicar

brevemente lo que hace el programa y facilitar así el recordar que es lo que se están tratando de programar. Los comentarios deben ser escrito en cualquier lugar donde pueda haber confusión. En C debe ser escrito entre /* y */.

• Un comentario también se muestra en una sola línea de código; pero se representa así: //

- VARIABLE GLOBAL Una declaración global de una variable, hace que la variable sea disponible para el uso en todas las funciones del archivo fuente.

- BUCLES Es un segmento de un algoritmo o programa, cuyas instrucciones se repiten un número determinado de veces mientras se cumple una determinada condición (existe o es verdadera la condición)

F u n c i o n e s d e u t i l e r í as t d l i b . h

E n t r a d a / S a l i d a s t d i o . h

F u n c i o n e s m a t e m á t i c a s m a t h . h

L i m i t e s e n t e r o s d e f i n i d o s e i m p l a n t a d o s l i m i t s . h

F l u j o d e e n t r a d a / s a l i d a i o s t r e a m . h

F u n c i o n e s d e u t i l e r í as t d l i b . h

E n t r a d a / S a l i d a s t d i o . h

F u n c i o n e s m a t e m á t i c a s m a t h . h

L i m i t e s e n t e r o s d e f i n i d o s e i m p l a n t a d o s l i m i t s . h

F l u j o d e e n t r a d a / s a l i d a i o s t r e a m . h

BUCLE INFINITOBUCLE INFINITO

Suma = 0

INICIO

Leer N

Escribir suma

SumaSuma + N

1

2

3


43

Un bucle consta de tres partes:

o Decisión

o Cuerpo de bucle

o Salida de bucle.

TIPOS BUCLES

• Pueden existir varios bucles.

Bucles anidados, cuando están dispuestos de tal modo que unos son interiores a otros, los Bucles independientes son cuando son externos unos a otros.

Bucles anidados Bucles Independientes

Bucles Cruzados

B u c le A

B u c le B

B u c le C

IN IC IO

F IN

B u c le A

B u c le B

B u c le C

IN IC IO

F IN

in ic io

fin

in ic io

fin

inicio

fin


44

2.2 ESTRUCTURA DE ALGORITMO Los algoritmos deben ser escritos en lenguajes similares a los programas. Un algoritmo constará de dos componentes: Una cabecera de programas y un bloque algoritmo. La cabecera de programa es una acción simple que comienza con la palabra algoritmo. Esta palabra estará seguida por el nombre asignado al programa completo. El bloque algoritmo es el resto del programa y consta de dos componentes o secciones: las acciones de declaración y las acciones ejecutables. Las declaraciones definen o declaran las variables y constantes que tengan nombres. Las acciones ejecutables son aquellas que posteriormente deberá realizar la computadora cuando el algoritmo convertido en programa se ejecute.

2.3 CONTADORES, ACUMULADORES. • CONTADORES

DEFINICIÓN 1: Se utilizan para llevar el control del número de ocasiones en que se realiza una operación o se cumple una condición. Con los incrementos generalmente de uno en uno. DEFINICIÓN 2: Un contador es una variable cuyo valor se incrementa o decrementa en una cantidad constante cada vez que se produce un determinado suceso o acción. Los contadores se utilizan con la finalidad de contar sucesos o acciones internas de un bucle; deben realizar una operación de inicialización y posteriormente las sucesivas de incremento o decremento del mismo.

Algoritmo Cabecera del programa Sección de declaración Sección de acciones

45

La inicialización consiste en asignarle al contador un valor. Se situará antes y fuera del bucle. Representación de contadores: Son variables que se utilizan para contar. Normalmente su valor se incrementa o decrementa en 1.

Ejemplos:

contador contador + 1 índice índice – 1

EJEMPLO Nº 9

BEGIN eCon 0

DO WHILE eCon <10 READ eR, eT eSun eR+eT eCon eCon+1

END DO END

• ACUMULADORES

DEFINICIÓN 1: Forma que toma una variable y que sirve para llevar la suma acumulativa de una serie de valores que se van leyendo o calculando progresivamente

o Se utilizan para almacenar el resultado de sumas

sucesivas. o Su valor se incrementa en cantidades variables.

Ejemplos:

total total + valor

DEFINICIÓN 2: Es una variable que suma sobre sí misma un conjunto de valores, de esta manera obtiene la suma de todos ellos en una sola variable. La diferencia entre un contador y un acumulador es que mientras el primero va aumentando en una cantidad fija

46

predeterminada, el acumulador va aumentando en una cantidad variable. Representación: <Nombre del acumulador> <nombre del acumulador> + <valor variable>

EJEMPLO Nº10:

BEGIN eCon 0,eAcu 0 DO WHILE eCon<=10 READ eNume eAcu eAcu+eNume eCon eCon+1 ENDDO WRITE eAcum END


47

2.4 PARTE PRÁCTICA


1.- Encontrar el valor de la variable VALOR después de la ejecución de las siguientes operaciones: a.- VALOR 4.0 * 5 b.- x 3.0

y 2.0 c.- VALOR 5 X 3 VALOR VALOR * X

2.- Deducir el resultado que se produce con las siguientes

instrucciones: var. entero: X,Y X 1 Y 5 Write X,Y

3.- Deducir el valor de las expresiones siguientes: X A +B+C X A +B*C X A +B/C X A –B/C X A +B mod C X (A +B)/C X A +(B/C) Siendo A=5, B=25, C=20

4.- ¿Cómo se intercambian los valores de dos variables, A y B? 5.- Calcular el valor de las siguientes expresiones:

a. 8+7*3+4*6 b. -2^3 c. (33 + 3 * 4) / 5 d. 2^2 *3 e. 3+2 * (18-4^2) f. 16*6-3*2


48

6.- Se tienen tres variables A, B y C; escribir las instrucciones necesarias para intercambiar entre sí sus valores del modo siguiente:

• B toma el valor de A • C toma el valor de B • A toma el valor de C

Nota: Solo se debe utilizar una variable auxiliar.

7- Deducir el valor que toma la variable tras la ejecución de las instrucciones: A 4 B A B A+3

8.- ¿Qué se obtiene en las variables A y B después de la ejecución de

las siguientes instrucciones? A 5 B A+6 A A+1 B A-5

9.- ¿Qué se obtiene en las variables A, B y C después de ejecutar las

instrucciones siguientes? A 3 B 20 C A+B B A+B A B-C

10.- ¿Que se obtiene en A y B tras la ejecución de?

A 10 B 5 A B B A

11. Se desea calcular independiente la suma de los números pares e

impares comprendidos entre 1 y 200. 12. Leer una serie de números distintos de cero (el último número de la

serie es -99) y obtener el número mayor. Como resultado se debe


49

visualizar el número mayor y un mensaje de indicación de número negativo, caso de que se haya leído un número negativo.

13. Calcular y visualizar la suma y el producto de los números pares

comprendidos entre 20 y 400, ambos inclusive. 14. Leer 500 números enteros y obtener cuántos son positivos. 15. Se trata de escribir el algoritmo que permita emitir la factura

correspondiente a una compra de un artículo determinado, del que se adquieren una o varias unidades. El IGV a aplicar es del 19% y si el precio bruto es mayor a s/.50000, se debe realizar un descuento del 5 por 100.

16. Sumar los números pares del 2 al 100 e imprimir su valor. 17. Sumar cinco números introducidos por teclado. 18. Calcular la media de tres números e imprimir su resultado.

19. Dados diez números enteros, visualizar la suma de los números pares de una lista, cuántos números pares existen y cuál es la media aritmética de los números impares

LABORATORIO Nº 2

Este laboratorio tiene como objetivo que el alumno aprenda la Estructura de Los Programas Del Turbo C++. ESTRUCTURA DE UN PROGRAMA:

• INCLUSIÓN DE ARCHIVOS DE CABECERA

Para muchas tareas especificas el lenguaje C dispone de librerías de funciones preempacadas listas para ser usadas. Pero antes de utilizar cualquier de estas funciones debemos informar al compilador sobre las características de la función. Todo lo que tenemos que hacer es averiguar en que archivo de cabecera se encuentra el prototipo de la función a utilizar e incluir el archivo en nuestro programa mediante la directiva.

50

#include <nombre_archivo_cabecera>

Un archivo de cabecera se reconoce porque tiene extensión .h (como iostream.h, conio.h, string.h, etc.). Si las funciones a utilizar están en distintos archivos de cabeceras debe incluir todos ellos mediante una directiva #include para cada uno.

Ejemplo: // Importamos la cabeceras de los módulos que necesitamos

#include <iostream.h> // entrada / salida define las variables cin y cout (consola)

#include <string> // de la biblioteca estándar (STL)

• CUERPO DEL PROGRAMA Es la parte donde se desarrollan las instrucciones que conforman el programa. Aquí esta la parte medular del programa. Aquí es donde su algoritmo se convierte en programa.

La estructura general de un programa simple en C++:

Inclusión de archivos de cabecera

int main () { declaración de variables y constantes cuerpo del programa }

51

EXPLICACIÓN DE NUESTRO PROGRAMA Para lograr explicar con mayor claridad se repite el código anterior incluyendo un número de línea.

1. //Programa 01 2. //propósito: Estructura Secuencial 3. #include <iostream.h> 4. #include <conio.h> 5. int main() 6. { 7. // muestra mensaje endl permite un salto de línea 8. cout <<"Bienvenidos al primer programa " <<endl; 9. cout <<"utilizando C++"; 10. getch(); 11. return 0; 12. }

• Las líneas 1, 2,7 son comentarios que en tiempo de ejecución son ignoradas por el compilador.

• Las líneas 3 y 4 se conocen como directivas de procesador del compilador #include

• La línea 5 indica el inicio de la función principal main (). • Las líneas 6 y 12 indican el inicio y el fin de bloque de la

función principal. • La línea 8 muestra en pantalla el mensaje Bienvenidos al

Primer programa y un salto de línea. • La línea 9 muestra en pantalla el mensaje utilizando C++, • La línea 10 invoca a la función getch ( ) que espera a que el

usuario pulse una tecla. • La línea 11 pasa el valor 0 de regreso al sistema operativo.

Esto le indica al sistema operativo que el programa fue efectuado con éxito.

• DECLARACIÓN DE VARIABLES Y CONSTANTES

Todos los programas manejan datos. Estos datos se almacenan en localizaciones de memorias llamadas variables. En esta sección se informa al compilador sobre las variables que serán utilizadas en el programa (a esto se llama declarar variables). En C ++ permite declarar variables en cualquier parte del programa con tal que la variable se declare antes de ser utilizada.


52

VARIABLES Es un espacio en la memoria de la computadora que permite almacenar temporalmente un dato durante la ejecución de un proceso, su contenido puede cambiar durante la ejecución del programa. Una variable tiene las siguientes características:

1. Un nombre. 2. Un tipo de dato asociado. 3. Un valor inicial. 4. Una dirección de memoria.

CONSTANTES Una constante es un dato numérico o alfanumérico que no cambia durante la ejecución del programa.


53

LOS COMENTARIOS Con fines de documentación se pueden añadir comentarios a un programa. Los comentarios no generan código máquina sino que son ignorados por el compilador. Se considera como comentario: • Al texto que sigue a los dos slash // hasta el final de las línea. • Al texto ( una o mas líneas ) encerrado entre /* y */

Ejemplo:

// Este es un comentario de una sola línea. /* Este es el otro comentario de una sola línea * / /* Este es el ejemplo de un comentario de dos líneas */

54

• ENTRADA Y SALIDA BÁSICA EN C++

La entrada/salida (input/output) en C++ se hace mediante los objetos cin y cout. La forma más simple de entrada/salida se efectúa mediante las operaciones << (operador de inserción) y >> (operador de extracción). Toda la información que necesita el compilador sobre cin y cout se encuentra en el archivo de cabecera iostream.h, el que debe ser incluido en todo programa que use cin y cout escribiendo al principio del programa la línea:

#include <iostream.h>

Donde:

Cout es un flujo de datos que conecta el programa con la

pantalla. Cuando un programa desea enviar algo a la pantalla lo hace insertando los datos en el flujo cout y este a su vez se encarga de enviar los datos a la pantalla.

Cin es un flujo de datos que conecta el teclado con el programa.

Cualquier entrada desde el teclado es enviada primero al flujo cin. Luego el programa puede extraer (leer) datos desde este flujo.

55

• SALIDA A LA PANTALLA CON COUT

Salida de constantes:

Cout << constantes;

Donde la constante puede ser cualquier tipo de constante incluyendo las constantes de cadena. Recuerde que las constantes de cadena van encerradas entre comillas dobles, así para imprimir en la pantalla una constante de cadena escribiríamos:

Cout <<”aquí va la cadena a imprimir”; Salida de variables:

Cout << variable; Notas: La salida de cout se puede concatenar para hacer la salida de

distintas variables o cadenas en una sola sentencia. En una sentencia se puede enviar secuencias de escape con

la finalidad de mover el cursor al principio de la siguiente línea, hacer sonar a alarma del sistema, etc.

Pantall Cout << Variable

Teclad Cin >> Variable


56

SECUENCIA DE ESCAPE

Las secuencias de escape proporcionan un determinado significado al enviar ciertos caracteres especiales a la pantalla, a un archivo de disco o a la impresora. Todas las secuencias de escape comienzan con la barra invertida \.

Secuencia de

escape Descripción

\n

\r

\t

\a \` \” \\

Nueva línea. Coloca el cursor al principio de la segunda línea. Retorno de carro. Coloca el cursor al principio de la línea actual. Tabulador horizontal. Mueve el cursor al siguiente tabulador. Alerta. Hace sonar la campana del sistema. Imprime una comilla simple (`). Imprime una comilla doble (“). Imprime una barra invertida (\)

• ENTRADA DESDE EL TECLADO DE CIN

La entrada o lectura desde el teclado para cualquier variable se hace mediante la sentencia:

Cin >> variable;


57

Notas: La entrada con cin se puede concatenar para poder hacer la

entrada de distintas variables o cadenas en una sola sentencia.

Cin desprecia los caracteres blancos (espacios, tabuladores y saltos de línea) al realizar la entrada desde el teclado. Esto significa que no se puede leer con cin cadenas que contengan espacios en blanco pues cin únicamente leerá la parte de la cadena hasta el primer blanco. Si se desea leer cadenas que contengan espacios en blanco use la función gets.

• LA FUNCIÓN GETS PARA LA ENTRADA DE CADENAS Gets (cad);

La función gets lee una cadena de caracteres ingresada desde el teclado, incluyendo espacios en blanco, y lo almacena en la variable de cadena cad. Para usar la función gets debe incluirse el archivo de cabecera stdio.h.


58

• OPERADORES DE INCREMENTO Y DECREMENTO

operador Acción

++ --

Suma 1 a su operando Resta 1 a su operando

Uso de ++ y – en expresiones simples Sea n una variable cualquiera.

Expresión Forma equivalente 1 Forma equivalente 2

n = n + 1; n = n – 1;

n ++; n --;

++ n; -- n;

Uso de ++ y – en otras expresiones En expresiones de asignación u otras que no sean del tipo simple se cumple que:

Si ++ ó – están antes del operando, primero se suma o resta 1 al

operando antes de continuar con lo que sigue. Si ++ ó – están después del operando, primero se usa el valor

del operando y luego se le suma o resta 1.


59

CAPÍTULO III: ESTRUCTURAS DE CONTROL

3.1 PROGRAMACIÓN ESTRUCTURADA

• DEFINICIÓN La programación estructurada es una forma de programar de forma clara, para ello utiliza únicamente tres estructuras: secuencial, selectiva simple e iterativa; siendo innecesario y no permitiéndose el uso de la instrucción o instrucciones de transferencia incondicional (GOTO).

• VENTAJAS DE LA PROGRAMACIÓN ESTRUCTURADA - Los programas son más fáciles de entender. Un

programa estructurado puede ser leído en secuencia, de arriba hacia abajo, sin necesidad de estar saltando de un sitio a otro en la lógica, lo cual es típico de otros estilos de programación.

- Los programas quedan mejor documentados internamente.

- Reducción de los costos de mantenimiento. - Aumento de la productividad del programador.

• DESVENTAJAS DE LA PROGRAMACIÓN ESTRUCTURADA - Es relativamente difícil de aprender ya que es para

expertos. 3.2 ESTRUCTURA DE CONTROL – TIPOS

En lenguajes de programación, las estructuras de control permiten modificar el flujo de ejecución de las instrucciones de un programa.

Con las estructuras de control se puede:

De acuerdo a una condición, ejecutar un grupo u otro de sentencias (IF-ELSE y CASE OF)

Ejecutar un grupo de sentencias HACER MIENTRAS exista una condición (DO-WHILE)


60

Ejecutar un grupo de sentencias REPETIR -HASTA que exista una condición (REPEAT-UNTIL)

TIPOS

SECUENCIAL SELECTIVA SIMPLE ITERACIÓN

3.2.1 SECUENCIAL

La estructura secuencial se refiere a la ejecución de una secuencia de instrucciones en el orden en que aparecen, de forma que cada instrucción se ejecuta exactamente una vez.

EJEMPLO Nº 11

BEGIN REAL base, altura, área, perímetro READ base, altura área base*altura perímetro 2*(base+altura) WRITE área, perímetro END

Esta secuencia de instrucciones permuta los valores de x e y, con ayuda de una variable auxiliar, intermedia.

1º Guardamos una copia del valor de x en auxiliar. 2º Guardamos el valor de y en x, se pierde el valor anterior de x

pero no importa porque tenemos una copia en auxiliar. 3º Guardamos en y el valor de auxiliar, que es el valor inicial de x.

El resultado es el intercambio de los valores de x e y, en tres operaciones secuenciales.

ESTRUCTURA SELECTIVA

Las estructuras de selección son estructuras de control utilizadas para la toma de decisiones dentro de un programa. A estas estructuras se les conoce también como estructuras selectivas o estructuras de decisión.


61

• TIPOS DE ESTRUCTURA SELECTIVA 3.2.2 SELECTIVA SIMPLE IF (SI)

La estructura selectiva simple SI (en ingles IF) ejecuta una determinada acción cuando se cumple una determinada condición.

La selección SI evalúa la condición.

- Si la condición es verdadera, entonces ejecuta la acción

S1 (o acciones caso de ser S1 una acción compuesta y constar de varias acciones)

- Si la condición es falsa, entonces no hace nada.

DIAGRAMA DE FLUJO:

ESTRUCTURA ESTRUCTURA SELECTIVA SIMPLESELECTIVA SIMPLE

ESTRUCTURA ESTRUCTURA SELECTIVA DOBLESELECTIVA DOBLE

ESTRUCTURA ESTRUCTURA SELECTIVA MULTIPLESELECTIVA MULTIPLE

ESTRUCTURAESTRUCTURADDEE

SELECCIONSELECCION

condición

accionS1

verdadera

falsacondición

accionS1

verdadera

falsa

62

SINTAXIS:

EJEMPLO Nº 12: PSEUDOCÓDIGO: • Construya un algoritmo en pseudocódigo tal que, dado los

valores enteros P y Q, que deben leerse del teclado, determine si los mismos satisfacen la siguiente expresión:

• En este caso debe escribir por pantalla los valores P y Q.

ALGORITMO Problema VARIABLES p, q SON ENTEROS BEGIN WRITE p WRITE q IF p^3 + q^4 -2*p^2<680 WRITE “Los Valores de p y q son:” WRITE “p=“, p, “q=“, q END_SI END

SINTAXIS EN ESPAÑOL

SI <condición> <acción S1>

FIN _ SI

SINTAXIS EN INGLES

IF <condición>

<acción S1>

ENDIF

63

EN C++: Según una calificación imprimir si es aprobada

#include <stdio.h> #include <conio.h> int main () {

float Cal; clrscr(); printf ("Introduzca la calificación: ");

scanf ("%f", &Cal); if ( Cal >= 11 ) printf("Aprobó."); return 0; }

3.2.3 SELECTIVA DOBLE ( SI - SINO)

La estructura de selección doble permite seleccionar una ruta de dos rutas posibles en base a la verdad o falsedad de una condición.

Si la condición es verdadera, entonces ejecuta la acción

S11 (o acciones caso de ser S11 una acción compuesta y constar de varias acciones)

Si la condición es falsa, entonces ejecuta la acción S21 (o acciones caso de ser S21 una acción compuesta y constar de varias acciones)

DIAGRAMA DE FLUJO

¿Condición?

acción S21

si no

acción S11

¿Condición?

acción S21

si no

acción S11

¿Condición?

acción S21

si no

acción S11

64

SINTAXIS:

EJEMPLO Nº 13 La siguiente estructura de selección doble determina si una persona es mayor o menor de edad:

IF edad >= 18

estado "Mayor de edad“

ELSE estado "Menor de edad“ ENDIF WRITE estado

Esto imprime "Mayor de edad", si la persona tiene 18 años a más e imprime "Menor de edad" si la persona tiene menos de 18 años. En cualquiera de los casos, después se efectuará la impresión

EN C++: Imprimir si un número es par o impar

#include <stdio.h> #include <conio.h> int main()

PSEUDOCODIGO EN ESPAÑOL

SI <condicion> <accion S11>

<accion S12> …

<accion S2n> SI_NO <acción 21> <acción 22> … <acción S1n>

FIN_SI

PSEUDOCODIGO EN INGLES

IF <condición> <acción S11> <acción S12> … <acción S2n> ELSE

<acción 21> <acción 22>

… <acción S1n>

ENDIF


65

{ int num; clrscr();

printf("Introducir un número:\n"); scanf("%d",&num);

if ( num % 2 == 0 ) printf("%d es par.",num); else printf("%d es impar.",num); return 0; }

3.2.4 SELECTIVA MULTIPLE IF – ELSE- IF ( SI – SINO - SI)

Puede contener instrucciones sencillas o compuestas. Pueden estar incluidas una o más instrucciones If - else. Al incluir una o más instrucciones de if en una instrucción de if existente se crean las instrucciones anidadas If.

EJEMPLO Nº 14 Este algoritmo lee tres números A, B, C, imprimiendo el valor del más grande. Se supone que los tres valores son diferentes.

Read (A, B, C) // Entrada de valores

if A > B // Se determina el valor más grande mediante comprobación // por pares

then if A > C

then MAX A (A > B, A > C)

else MAX C (C > A > B)

else if B > C

then MAX B (B > A, b > C)

else MAX C (C > B > A)

Write `El valor más grande es`, MAX // Se imprime el valor más grande

Exit // Termino

66

EJEMPLO Nº 15

#include<iostream.h>

int main ( )

{

char codigo;

cout << "Introduzca un código especificado: ";

cin >> codigo;

if (codigo == 'S' )

cout << "El componente tiene calificación de exploración espacial . ";

else if (codigo == ‘M’)

cout << "El componente tiene calificación de militar. ";

else if (codigo == ‘C’)

cout << "El componente tiene calificación de comercial. ";

else if (codigo == 'J' )

cout << "El componente tiene calificación de juguete. ";

else

cout << "Se insertó un código invalido. ";

cout << endl;

getch();

return 0;

}

3.2.5 SELECTIVA DE CONTROL CASE OF ( SEGÚN SEA) Esta sentencia se utiliza para elegir entre diferentes alternativas. Esta se compone de varias sentencias simples, cuando se ejecuta, una y solo una de las sentencias simples se selecciona y ejecuta.


67

La sintaxis es la siguiente:

Según sea (selector) hacer caso1, caso2, ..: sentencia 1 .... : ..... caso1n, caso2n, ..: sentencia n sino sentencia opcional fin_según

El valor de selector debe ser un tipo ordinal, y los valores constantes deben tener el mismo tipo que el selector. Se pueden utilizar sentencias if anidados, pero la sentencia según sea es más legible.

SINTAXIS: PSEUDOCÓDIGO EN ESPAÑOL En caso que E sea

c1: acción S1 c2: acción S2 … cn: acción Sn>

de otra forma: acción Sx

fin_caso

PSEUDOCÓDIGO EN INGLES CASE EXPRESION OF

[c1]: acción S1 [c2]: acción S2 … [cn]: acción Sn>

otherwise acción Sx ENDCASE

Condición1 n

AcciónS1

AcciónS2

AcciónS3

AcciónS4

AcciónSn

……

2 34

Condición1 n

AcciónS1

AcciónS2

AcciónS3

AcciónS4

AcciónSn

……

Condición1 n

AcciónS1

AcciónS2

AcciónS3

AcciónS4

AcciónSn

……

2 34

68

EJEMPLO Nº 16 EN C++: Imprimir a que día de la semana corresponde un número.

#include <stdio.h> #include <conio.h> int main() { int Dia; clrscr(); printf("Escriba el número de día: \n"); scanf("%d",&Dia); switch(Dia)

{ case 1: printf("El %d corresponde a Lunes.",Dia);

break; case 2: printf("El %d corresponde a Martes.",Dia);

break; case 3: printf("El %d corresponde a

Miércoles.",Dia);break; case 4: printf("El %d corresponde a Jueves.",Dia);

break; case 5: printf("El %d corresponde a Viernes.",Dia);

break; case 6: printf("El %d corresponde a Sábado.",Dia);

break; case 7: printf("El %d corresponde a

Domingo",Dia);break; default: printf ("El %d día no existe en la

semana.",Dia); getch(); }

return 0; }


69

ESTRUCTURAS ITERATIVAS ó CÍCLICAS INTRODUCCIÓN Son aquellas que permiten ejecutar una acción un número determinado de veces, es decir, repetir esa acción una o más veces consecutivamente. Las Estructuras Iterativas se suelen llamar LAZOS o BUCLES; todas las instrucciones incluidas en los bucles se repiten un número determinado de veces, el cual puede ser fijo (previamente determinado por el programador) o puede ser variable. Se denomina iteración a cada una de las diferentes pasadas o ejecuciones de todas las instrucciones contenidas en el bucle. TIPOS DE ESTRUCTURA ITERATIVAS: Las Estructuras Repetitivas o Iterativas más importantes son:

Estructura REPEAT UNTIL (Repetir – Hasta). Estructura DO WHILE (Hacer – Mientras).

3.2.6 ITERATIVA (REPETIR – HASTA) La sentencia REPEAT UNTIL especifica un ciclo condicional que se repite hasta que la condición se hace verdadera.

Permiten programar la repetición de un grupo de sentencias mediante la construcción denominada ciclo o bucle. El grupo de sentencias que tiene que repetirse se llama rango del ciclo. El numero de veces que ha de repetirse el rango esta determinado por la “sentencia de control” de ciclo. Generalmente se quiere que un bucle se ejecute, mínimo una vez, antes de que la condición de repetición sea cumplida o se compruebe. En la estructura mientras, si la condición es falsa, no se dará ninguna ejecución.

70

Esta estructura se ejecutará mientras se cumpla una condición determinada, la cual es comprobada al final del bucle Debe contener al menos una variable que cambie o se modifique cada vez que se ejecuta la repetición, de lo contrario se repite infinitamente.

SINTAXIS:

PSEUDOCÓDIGO EN ESPAÑOL Repetir <acciones>

………

<acciones n>

Hasta <condicion>

PSEUDOCÓDIGO EN INGLES Repeat <acciones>

...

<acciones n>

Until <condicion>

DIAGRAMA DE FLUJO

CARACTERÍSTICAS

o La estructura REPEAT UNTIL modela ciclos postprobados: el cuerpo siempre se ejecuta.

o La estructura REPEAT UNTIL realiza un número variable de iteraciones.

o Cualquier ciclo REPEAT UNTIL puede traducirse en un ciclo DO WHILE.


71

ERRORES COMUNES Realizar ciclos infinitos. ¿Como se evitan? Modificando dentro del cuerpo la

variables que lo controlan. Pensar que puede no ejecutarse ninguna vez. Todas las operaciones durante la primera ejecución del

cuerpo son válidas. La primera ejecución del cuerpo modifica las variables

de la condición.

EJEMPLO Nº 17 Desarrollar el algoritmo necesario para calcular el factorial de un numero N que responda a la formula

N! = N (N–1) * (N–2), …3*2*1

ALGORITMO FACTORIAL VAR

entero i, n real factorial

BEGIN WRITE N

factorial 1 i 1

REPEAT factorial factorial * i i i+1 UNTIL i n – 1 WRITE factorial END

72

3.2.7 ESTRUCTURA ITERATIVA DO WHILE (HACER – MIENTRAS)

La estructura repetitiva DO WHILE es aquella en la que

el número de iteraciones no se conoce por anticipado y el cuerpo del bucle se ejecuta repetidamente mientras que una condición sea verdadera.

El bucle DO WHILE resulta especialmente indicado para validar datos de entrada (comprobar que los valores de entrada obtenidos esta dentro del rango de valores que el programa espera).

En todos los programas se deben asegurar de obtener entradas validas antes de realizar cualquier tipo de operación con ellos.

SINTAXIS

DIAGRAMA DE FLUJO

SINTAXIS EN ESPAÑOL

HACER MIENTRAS Condición

<Acción>

… FIN HACER

SINTAXIS EN INGLÉS

DO WHILE Condición

<Acción>

… ENDDO

73

EJEMPLO Nº 18 Desarrollar el algoritmo necesario para calcular el factorial de un numero N que responda a la formula

N! = N (N–1) * (N–2), …3*2*1

ALGORITMO FACTORIAL VAR Entero I, N real factorial BEGIN READ factorial factorial 1

I 1 DO WHILE I< = N factorial factorial * 1 I I + 1 ENDDO WRITE factorial

END EN C++

EJEMPLO Nº 19 // Algoritmo que calcula el factorial de un numero.

#include "conio.h" #include <stdio.h> #include <dos.h> int main() { int i, total,contador; contador=1; total = 1; clrscr(); printf ("Factorial numero\n\n Dame el numero para el factorial: "); scanf ("%d",&i);

74

while (contador<=i) { total = total * contador; contador++; } printf("El factorial de %d es: %d",i,total); getch(); return 0; }

3.3 PARTE PRÁCTICA


1. Realizar el pseudocódigo que lea 5 números enteros y que los

imprima

2. Diseñar el pseudocódigo para imprimir los 50 primeros números pares.

3. Construir un programa que sume todos los números que introduce

el usuario hasta que introduzca el número cero.

4. Diseñar el pseudocódigo para imprimir los 50 primeros números impares.

5. Diseñar el algoritmo que permita el ingreso de n números, y que

muestre si son pares o impares.

6. Calcular la suma y la media aritmética de N números reales.

7. Diseñar un algoritmo que permita calcular la edad promedio de n personas.

8. Dados N números, escribir el producto desde 1 hasta N.

9. Diseñar el algoritmo que permita imprimir los 30 primeros múltiplos

de un número dado N.


75

10. Realizar un algoritmo que realice la división entera de dos números enteros positivos.

11. Realizar el algoritmo que calcule la suma de los cuadrados de los N

números naturales.

12. Desarrollar un algoritmo para calcular e imprimir el factorial de N números.

13. Diseñar un algoritmo en pseudocódigo para que dado N números

permita calcular el promedio de los múltiplos de M.

14. Diseñar un programa que permita ingresar 2 notas para 5 alumnos, luego nos muestre el promedio general de notas de los alumnos ingresados.

15. Dado N datos, calcular el promedio de las notas aprobadas y el

promedio de las notas desaprobadas.

16. Realizar el algoritmo que identifique si un número es primo o no.

(Primo es cuando sólo se puede dividir por si mismo o por uno).

17. Diseñar el pseudocódigo que permita imprimir los 50 números primos.

18. Realizar un algoritmo que permita pedir 50 números naturales y

determine e imprima cuantos son pares, impares, positivos y negativos.

19. Los pacientes con síntomas de una cierta enfermedad son

ingresados en el hospital si tienen un valor superior a 0.6 en la medición de un determinado índice, y son operados si el valor es superior a 0.9. Escribe un programa en C que lea desde teclado el número de pacientes seguido de la edad y el índice de cada paciente, y calcule la edad media de los pacientes analizados así como la edad media de los ingresados y la edad media de los operados.

20. Se conocen los gastos en vivienda, alimentación, energía,

vestuario y transportes de una familia durante cada uno de los 12 meses del año. Escribe un programa en C que lea dichos datos y muestre por pantalla el gasto total en cada trimestre, el gasto total


76

anual y el porcentaje de gasto de cada concepto sobre el total anual.

21. Se dispone de los datos sobre las edades y coeficientes de

inteligencia (CI) de los hijos de varias familias. El siguiente programa en C lee el número de familias y para cada familia lea el número de hijos así como la edad y el CI de cada hijo, y calcula:

• El número máximo, mínimo y promedio de hijos por familia. • El CI máximo, mínimo y promedio de todos los hijos. • El CI promedio de los hijos menores de 6 años. • El CI promedio de los hijos mayores de 6 años.

22. Una persona dispone de una cantidad de X pesetas que quiere

repartir a un conjunto de personas. A cada persona le da una cantidad de dinero proporcional a la edad de la misma. Por ejemplo, si una persona tiene 17 años recibirá 17000 pesetas y si tiene 32 años recibirá 32000. El problema consiste en diseñar un algoritmo que devuelva el número de personas que podrán recibir una cantidad de dinero. Cuando la cantidad de dinero ya no es suficiente para dársela a una persona, suponemos que no existen más personas y que por tanto el programa finaliza.

23. El número de individuos de una población animal afectada por una

epidemia se reduce a la quinta parte cada año. Escribe un programa en C que lea el número de individuos inicial y un número de años N y escriba el número de individuos que quedarán en cada uno de los siguientes N años (al cabo de 1 año, a cabo de 2 años,..., al cabo de N años).

24. Escribir un programa que lea 5 números y encuentre el promedio, el máximo y el mínimo de esos valores.

25. Escribir un programa que lea números hasta que se encuentre el

cero. El segundo número se sumará al primero, luego el tercero se restará, el cuarto se sumará, y así se deberá seguir alternado hasta que se llegue al cero. Cuando se llegue a esta condición deberá imprimir el resultado, el total de operando de la operación (sin incluir el cero), y la suma de los operando que se restaron.


77

26. Escribir un programa que lea un valor entero que será la base para un sistema numérico (binario, octal o decimal), después que lea un entero positivo en esa base y que imprima su valor en base 10. Se debe validar que el número pertenezca a esa base. La base será menor que o igual a 10. El programa podría tener la siguiente salida:

Entrada Salida

Base Número ============== ========= 10 1234 1234 8 77 63 2 1111 15

27. Escribir un programa que lea un número en base 10 y lo convierta a

base 2, base 8 y base hexadecimal.

28. Leer tres valores representando lo siguiente:

El capital (número entero de pesos) Una tasa de interés en por ciento (flotante) Un número de años (entero).

Calcular los valores de la suma del capital y el interés compuesto para un período dado de años. Para cada año el interés es calculado como:

Interés = capital * tasa _ interés / 100; el cual se suma al capital Capital += interés; Imprimir los valores de moneda con una precisión de dos decimales. Imprimir los valores del interés compuesto para cada año al final del período. La salida puede ser como la siguiente:

Capital inicial 35000.00 con tasa del 12.50 en 10 años

Año interés Suma -----+-----------+--------- 1 4375.00 39375.00 2 4921.88 44296.88 3 5537.11 49833.98 4 6229.25 56063.23 5 7007.90 63071.14

78

6 7883.89 70955.03 7 8869.38 79824.41 8 9978.05 89802.45 9 11225.31 101027.76 10 12628.47 113656.23

LABORATORIO Nº 3

1. Diseñe un programa de valide la entrada de un número positivo.

Pseudocódigo:

BEGIN DO Ingresar el dato número WHILE numero <= 0 WRITE el número validado END

Código: #include<iostream.h> #include<conio.h> int main () { float numero; clrscr (); cout << "VALIDACIÒN DE LA ENTRADA DE UN NUMERO POSITIVO" << endl; do { cout<< "Ingrese el numero positivo:"; cin>>numero; }while(numero <= 0 ); cout<< "\n El numero es " ; cin>>numero; getch (); }

79

2. Escribir un programa que halle la suma de N números enteros.

Código: # include<iostream.h> # include<conio.h> int main () { int N, numero, cont = 0, suma = 0; clrscr (); cout << “SUMA DE NÚMEROS ENTEROS” << endl; cout << “¿Cuántos números desea sumar? ”; cin >> N; do { cout << “Ingrese número ” << cont << “ : “; cin >> numero; suma += numero; cont++; }

while ( cont < N ) ; cout << “ \ nLa suma es ” << suma; getch (); }

3. Diseñar el programa que halle el área y el perímetro de un

rectángulo.

#include "iostream.h" #include "conio.h" int main() { //Declaramos dos variables tipo enteras y una de tipo float float base, altura, area, perimetro;

80

// Ingreso de datos cout<<"Base: "; cin>>base; cout<<"Altura: "; cin>>altura; area = base * altura; perimetro = 2 * (base * altura); //Salida de datos cout << "El area es :" <<area<<endl; cout << "El perimetro es :" << perimetro<<endl; getch(); return 0; }

4. Escribir un programa que pida un número y si el que se introduce por el teclado es menor de 100 que vuelva a solicitarlo.

PROGRAM EJER02;

VAR num:INTEGER;

BEGIN ClrScr;

REPEAT

WRITELN ('Introduzca un número: '); READLN (num);

UNTIL num > 100;

END

5. Diseñar un programa que imprima la siguiente serie:

1,2,………,10 un numero en cada línea.

#include <iostream.h> #include <conio.h>

81

int main() {

int numero=0; do {

numero= numero+1; cout << “\t” <<numero<<endl; } while (numero <10);

cout <<"\n\t Fin de programa "; getch() ; return(numero) ; }


82


83

CAPÍTULO IV: SUBPROGRAMACIÒN

4.1 PROGRAMACIÓN MODULAR

• La programación modular es una de las técnicas fundamentales de la programación, que consiste en dividir el problema dado, en problemas más simples, los cuales son a su vez, implementados mediante módulos independientes.

• Cada uno de estos módulos recibe el nombre de subalgoritmos o subprogramas.

• Existe un módulo o programa principal con el que comienza la ejecución de todo el programa y que actúa como “coordinador” de las invocaciones y ejecuciones del resto de los módulos.

• Un subprograma posee la misma estructura de un programa, puede tener su propia declaración de variables, junto a un conjunto de parámetros, que constituyen el mecanismo para transferir datos al subprograma.

Programa

• Los módulos son independientes en el sentido de que ningún módulo, puede tener acceso directo a otro módulo, con excepción del módulo, al que se llama y sus propios submódulos. Sin embargo los resultados producidos por un módulo puede ser utilizados por cualquier otro módulo cuando se transfiera a ellos el control.


84

VENTAJAS • Facilita el diseño descendente. • Disminuye la complejidad del algoritmo. • Disminuye el tamaño total del programa. • División de la programación entre un equipo de

programadores - reducción del tiempo de desarrollo. • Facilidad en la depuración : Comprobación individual de los

módulos • Programas más fáciles de modificar. • Estructuración en librerías específicas (biblioteca de

módulos).

EJEMPLO Nº 20 Se desea diseñar un algoritmo que realice las siguientes tareas:

• Impresión. • Lectura de datos. • Ejecutar cálculos. • Imprimir líneas detalladas de información. • Imprimir totales.

Este algoritmo podemos resolverlo utilizando módulos, de modo que exista un módulo principal de control y diferentes submódulos.

Módulo principal:

• Llamada al submódulo “Impresion”. • Llamada al submódulo “proceso de datos”. • Llamada al submódulo “Imprimir totales”. • Fin de proceso.

Submódulo “Impresion”:

• Instrucción para impresión. • Retorno al módulo principal.

Submódulo “proceso de datos”:

• Lectura de datos. • Ejecución de cálculos. • Impresión detallada de líneas de información. • Retorno al módulo principal.

85

Submódulo “Imprimir totales”: • Instrucciones de impresión de totales. • Retorno al módulo principal.

4.2 SUBPROGRAMAS – TIPOS

Tipos de Subprogramas:

Procedimientos

Funciones

PROCEDIMIENTOS o Un procedimiento es un algoritmo que realiza una tarea

específica, pero que generalmente no devuelve ningún resultado.

o La entrada de información se realiza a través de los parámetros.

o En caso necesario la salida de información también se realiza a través de los parámetros.

o Para invocar a un procedimiento se utiliza la instrucción llamar a seguida del nombre del procedimiento y de los parámetros actuales sobre los que aplicarlo, escritos entre paréntesis y separados por comas.

DECLARACIÓN DE LOS PROCEDIMIENTOS

PROCEDIMIENTO <nombre> ([lista de parámetros formales])

CONST <declaración de constantes>

VAR <declaración de variables>

BEGIN ...

< acciones>

END_PROCEDIMIENTO

86

EJEMPLO Nº 21

PROCEDIMIENTO división (E entero: Dividendo, Divisor; S

entero: Cociente, Resto)

BEGIN

Cociente Dividendo div Divisor

Resto Dividendo - Cociente * Divisor

END_PROCEDIMIENTO

FUNCIONES o Una función toma uno o más valores, denominados

argumentos o parámetros formales y devuelve un resultado. o Para invocar a una función se utiliza su nombre seguido por

los parámetros actuales sobre las que se aplicará, escritos entre paréntesis y separados por comas en una expresión.

o Cada lenguaje de programación tiene sus propias funciones

internas incorporadas. Si estas no permiten realizar el tipo de cálculo deseado será necesario declarar una función externa.

DECLARACIÓN DE LA FUNCIONES

<tipo de dato> función <nombre de la función> (<parámetros formales>) CONST <declaración de constantes>

VAR <declaración de variables>

BEGIN ...

devolver <resultado>

END

87

EJEMPLO Nº 22

Función Factorial (n: entero): entero

var i, factorial:entero

BEGIN

IF (n<=1) ENTONCES factorial 1 ELSE factorial 1 FOR i 1 TO n DO factorial factorial *1 ENDIF END

EJEMPLO Nº 23

Evaluar la función ƒ=x!/(y!(x-y)!) Algoritmo Hallar ƒ

Var x,y: entero

ƒ: real

BEGIN

READ (x,y)

ƒ factorial(x)/factorial(y)*factorial(x-y))

WRITE (“El valor de ƒ es:”,ƒ)

END

4.2.1 VARIABLES GLOBALES Y LOCALES.

- Variables Locales: Una variable local es una variable que esta declarada

dentro de un subprograma y se dice que es local al subprograma.

Una variable local solo está disponible durante el funcionamiento del subprograma, al terminar su función el subprograma y regresar al programa llamador, se pierde el valor que se encontraba guardado en la variable local.


88

EJEMPLO Nº 23 Algoritmo local var x entero

BEGIN

x 0

cambiar

WRITE (x)

END

Módulo cambiar var x entero

BEGIN

x 1

END

Como x es local, no tiene efecto en el programa, por lo tanto la

salida será 0.

- Variables Globales: Las variables declaradas en el programa principal se

denominan variables globales. Las variables globales se pueden utilizar en todo el

programa principal y en todos los subprogramas, donde se haga referencia al identificador de esta variable.

EJEMPLO Nº 24

Algoritmo global var x entero

BEGIN

x 0

cambiar

write (x)

END


89

Módulo cambiar

BEGIN x 1 END

La variable x esta definida como global, por lo tanto la salida

será 1.

4.2.2 FUNCIONES, PASO DE PARÁMETROS.

• PASO DE PARÁMETROS o Existen diferentes métodos para la transmisión o el

paso de parámetros o subprogramas. o Es preciso conocer el método adoptado por cada

lenguaje, un mismo programa puede producir diferentes resultados bajo diferentes sistemas de paso de parámetros.

o Los parámetros pueden ser clasificados como:

Entrada (E)

Las entradas proporcionan valores desde el programa que llama y que se utilizan dentro de un procedimiento. En los programas función, las entradas son los argumentos en el sentido tradicional

Salidas (S)

Las salidas producen los resultados del subprograma: de nuevo si se utiliza el caso una función, este devuelve un valor calculado por dicha función, mientras que con procedimientos puede calcularse cero, una o varias salidas

Entrada/salida (E/S)

Un solo parámetro se utiliza para mandar argumentos a un programa y para devolver resultados


90

EJEMPLO Nº 25

Acción modifica (var n: entero)

Ejemplo de Parámetro de entrada/salida

IF n >0 n n * 2 ELSE n n * 3 ENDIF

Los métodos más empleados para realizar el paso de parámetros

son:

Paso por valor (también conocido por Parámetro Valor)

Paso por referencia o diferencia (también conocido por

Parámetro Variable)

Paso por nombre

Paso por resultado

1) PASO POR VALOR Son los parámetros que pueden recibir valores pero no

pueden devolverlos. Los parámetros se tratan como variables locales y los

valores iniciales se proporcionan copiando los valores de los correspondientes argumentos.

El paso de parámetros por valor consiste en enviar una COPIA del valor de la variable al módulo invocado.


91

De esta manera se asegura que el valor de la variable sólo puede ser modificado por el módulo que la declaró.

EJEMPLO Nº 26 • El mecanismo de paso se resume así:

- Valor primer parámetro: A = 5

- Valor segundo parámetro: constante = 18

- Valor tercer parámetro: expresión B * 3 + 4 = 25

- El valor 5.18 y 25 se transforma en los parámetros X, Y, Z

respectivamente, cuando se ejecuta el procedimiento.

EJEMPLO Nº 27

ALGORITMO PARÁMETRO valor var x: entero BEGIN x 0 CAMBIAR (x) WRITE (x) END

Módulo cambiar (y: entero) BEGIN y 1 END SALIDA 0

A 5

B 7

Llamar_a PROC1 ( A, 18, 3 * 3 + 4)

5 18 25

procedimiento PROC1 (E entero) X, Y, Z)

A 5

B 7

Llamar_a PROC1 ( A, 18, B * 3 4)

5 18 25


A 5

B 7

Llamar_a PROC1 ( A, 18, 3 * 3 + 4)

5 18 25


A 5

B 7

Llamar_a PROC1 ( A, 18, B * 3 4)

5 18 25



92

2) PASO POR REFERENCIA

• Este método se denomina paso por referencia o también de llamada por dirección o variable.

• Son los que pueden recibir y devolver valores. • Son variables globales que se conectan con una local a

través de su contenido. • En el caso de que se requiera que el valor de una

variable sea modificado por el módulo invocado, debe hacerse el paso de parámetro por referencia, por medio del cual el módulo invocado tiene acceso a la dirección en que se guarda el valor a modificar.

EJEMPLO Nº 28

ALGORITMO PARÁMETRO

var x: entero

BEGIN

x 0

CAMBIAR (x)

WRITE (x)

END

Módulo cambiar (var y: entero)

BEGIN

y 1

END

SALIDA: x 1

3) PASO POR NOMBRE • En este caso, el parámetro formal se sustituye

literalmente por el parámetro actual asociado. • Esta sustitución literal del parámetro formal por el

parámetro actual no se produce hasta que no se usa el parámetro formal.


93

• La ventaja es que si no usamos en ningún momento el parámetro formal dentro del subprograma llamado (cosa poco probable), no se tendrá que hacer ningún tipo de sustitución.

4) POR RESULTADO

• Nos interesa el valor del parámetro real solamente a la salida o fin de la ejecución del subprograma en que aparece.

• Esto significa que al hacer la llamada no se copia el valor del parámetro real en el parámetro formal asociado, sin embargo a la salida se copia el valor del parámetro formal en la dirección del parámetro real asociado, significa por tanto, que el parámetro real tiene que tener asociada una expresión que tiene que ser una variable (no puede ser una constante).

EJEMPLO Nº 29 Algoritmo que contiene y utiliza unas funciones (seno y coseno) a las que les podemos pasar el ángulo en grados.

Algoritmo Sen_Cos_En_Grados VAR real: g BEGIN WRITE(´Deme angulo en grados´) READ(g) WRITE(seno(g)) WRITE(coseno(g)) END real funcion coseno (E real : g) BEGIN RETURN(cos(g * 2 * 3.141592/360)) END_FUNCION real funcion seno (E real g) BEGIN RETURN( sen(g * 2 * 3.141592/360)) END_FUNCION

94

EJEMPLO Nº 30

Diseñar un programa que permita calcular el valor absoluto de un número:

// Propósito: Funciones

#include <iostream.h> #include <conio.h> #include <math.h> int main() { int numero;

cout << "\nIngrese un numero : "; cin >> numero;

cout << "\nValor absoluto del numero es : " << abs(numero);

getch();

return 0;

}

4.3 PARTE PRÁCTICA


1. Diseñar una función llamada Fahrenheit que reciba como parámetro una temperatura en grados Centígrados y retorne la temperatura correspondiente en grados Fahrenheit. Escriba luego un programa que haga uso de la función Fahrenheit para convertir 20 temperaturas en grados Centígrados Fahrenheit.

2. Diseñar una función llamada hipotenusa que reciba como

parámetro de entrada los catetos de un triángulo rectángulo y retorne la longitud de la hipotenusa. Escriba luego un programa que ingrese los catetos de un triángulo rectángulo y calcule la longitud de su hipotenusa usando la función aquí diseñada.

3. Diseñar una función llamada espar que reciba como entrada un

número enteros y determine si es número es par en cuyo caso debe


95

retornar un 1, en caso contrario debe retornar un 0. Escriba luego un programa que muestre el uso de esta función.

4. Diseñar una función llamada signo que determine el signo de un

número real. Si el número es negativo retornar -1, si es positivo retornar 0 y si es 0 retornar 0. Escriba luego un programa que muestre el uso de esta función.

5. Diseñar una función llamada mes que reciba como parámetro de

entrada un número entero entre 1 y 12 e imprima el nombre del mes correspondiente. Así si se ingresa 1, se imprime “Enero”; si se ingresa 2, se imprime “Febrero”, etc. Si el número no está entre 1 y 12, no imprimir nada. Escriba luego un programa que imprima el nombre de todos los meses del año usando la función mes.

6. Diseñar una función llamada buscarlnt que busque un número

entero en un arreglo de enteros. La función debe recibir como parámetro de entrada el arreglo, el tamaño del arreglo y el número a buscar. Si el número esta en el arreglo debe retornar su índice en caso contrario retornar -1. Escriba luego un programa que demuestre el uso de esta función.

7. Diseñe una función llamada triángulo que permita obtener el área

y el perímetro de un triángulo conociendo la longitud de sus tres lados (a, b, c). No se permite el uso de variables globales. Escriba luego un programa que demuestre el uso de esta función.

Use: A = [p(p-a)(p-b)(p-c)]½

Donde p representa el semiperímetro del triángulo que se calcula con la fórmula: p = (a+b+c)/2.

LABORATORIO Nº 4 1. Diseñar una función llamado cuadrado que reciba como parámetro

un número entero y retorne su cuadrado. Luego diseñe un programa que ingrese un número N y a) Imprima el cuadrado de N, b) Calcule e imprima el valor de: 5N2+3N-5.

96

Solución: #include <iostream.h> #include <conio.h>

// Prototipo de la función cuadrado // Sería suficiente escribir: int cuadrado (int); int cuadrado (int n); // El programa comienza aquí int main ( ) { int N, resp; clrscr ( ); cout << “Ingrese un número entero N : ”; cin >> N; // Aquí usamos el retorno de la función, directamente en una // Sentencia de salida, cout << “\nForma 1: El cuadrado de N es ...: “ << cuadrado (N); // También puede crearse una variable para recibir el retorno de // La función y luego imprimimos el valor de la variable. Así:

int retorno = cuadrado (N);

cout << “\nForm 2: El cuadrado de N es ..: “ << retorno; // Aquí usamos el retorno de una función directamente en una // expresión.

resp = 5*cuadrado (N) + 3*N – 5; cout << “\nEl valor de 5N2 + 3N – 5 es.. ....: ” << resp;

getch ( ); } // Definición de la función cuadrado

int cuadrado (int) { // Esto muestra que una sentencia return se puede incluir el cálculo // De una expresión. Entonces primero se efectúa en calculo de la // Expresión y luego se retorna su valor. Return n*n; }

97

2. Diseñar una función llamado mínimo que reciba como parámetro tres números enteros y retorne el número menor. Escriba luego un programa que ingrese tres números enteros y determine el menor. Solución: #include <iostream.h> #include <conio.h> // Prototipo de la función mínimo int mínimo (int a, int b, int c); // Función principal int main ( ) { int A, B, C; clrscr ( ); cout << “Determinación del menor de tres números” << end1; cout << “Ingrese tres números enteros …….: ”; cin >> A >> B >> C; cout << “El menor de los tres números es ….: ” << mínimo (A, B, C); getch ( ); } / Definición de la función mínimo int mínimo (int a, int b, int c) { // Observe que la variable menor es una variable local y será // Destruida al salir de la función (luego del retorno). Int menor = a; If (b < menor) Menor = b; If (c < menor) Menor = c; Return menor; }

98

3. Diseñe una función llamada múltiplo que reciba como parámetro dos números enteros y determine si el primero es múltiplo del segundo en cuyo caso debe retornar 1 (verdadero) y, en caso contrario debe retornar 0 (falso). Luego escriba un programa que ingrese 10 pares de números enteros y determine si el primer número de cada par es múltiplo del segundo. Solución: #include <iostream.h> #include <conio.h> //Prototipo de la función múltiplo int multiplo (int a, int b); // Función principal int main ( ) { int m, n; clrscr ( ); for (int i = 0; i < 3; i ++) { cout << “Ingrese dos números enteros : ”; cin >> m >> n; // El if que sigue puede abreviarse como; if (múltiplo (m, n)) if (múltiplo (m, n) = = 1) cout << m << “es múltiplo de” << n << endl; else cout << m << “no es múltiplo de” <<n << endl; } cout << “\nPulse una tecla para terminar …”; getch ( ); } // Definición de la función múltiplo int múltiplo (int a, int b) { int r = 0; // Asumimos que a no es múltiplo de b if (a / b = = 0) // Pero si a es múltiplo de b… r = 1; return r; // Retornamos el indicador }

99

4. Diseñe una función llamada coutxy que imprima un texto

comenzando desde una coordenada dada de la pantalla usando cout. Escriba luego un programa que muestre el uso de esta función.

Solución: #include <iostream.h> #include <conio.h> // Prototipo de la función coutxy void coutxy (int x, int y, char texto [ ] ) ; // Función principal int main ( ) { clrscr ( ) ; coutxy (8, 2, “ Esto comienza en la coordenada (8, 2)”) ; coutxy (5, 5, “ Esto comienza en la coordenada (5, 5)”); coutxy (1, 8, “ Esto comienza en la coordenada (1, 8)”); coutxy (26, 25, “Pulse una tecla para terminar”); getch ( ); } // Definición de la función coutxy. // Note que la función no necesita retornar nada (todo lo que hace lo // Deja impreso en la pantalla) por lo que su tipo de retorno es void. void coutxy (int x, int y, char texto [ ]) gotoxy (x, y); // Poner el cursor en la coordenada (x, y) cout << texto; // Imprimir el texto desde la posición del cursor }

5. Diseñar una función llamada cuentach que retorne en número de repeticiones de un carácter en una cadena. La función debe recibir como parámetro la cadena y el carácter. Escriba luego un programa que ingrese una cadena y determine el número de repeticiones de cada una de las vocales no tildadas.

100

Solución: #include <stdio.h> #include <string.h> #include <iostream.h> #include <conio.h> int cuentach (char cad [ ], char ch); int main( ) { char cadena [80]; char vocal [] = “aeiou”; clrscr ( ); cout <<”Ingrese una cadena:”; gets (cadena); strlwr (cadena); cout << “\nNúmero de repeticiones de las vocales” << endl; for (int i = 0; i < 5; i ++)

cout << vocal [i] << “ : “<< cuentach (cadena, vocal [i]) << “veces” <<endl;

getch ( ); } int cuentach (char cad [], char ch)

{ int cont = 0, len = strlen (cad); for (int i = 0 ; i < len; i++) if (cad [i] == ch) cont ++; return cont; }

6. Diseñe una función llamado mirandom que genere un número

aleatorio entero entre el valor mínimo y un valor máximo. La función debe recibir como parámetro el valor mínimo, el valor máximo y retornar el número aleatorio en un parámetro por referencia. Escriba luego un programa que genere 20 números aleatorios entre 50 y 200.

101

Solución: #include <stdlib.h> #include <iostream.h> #include <conio.h> // Prototipo de función void mirandom (int& num, int min, int max); // Función principal int main ( ) {

int numero; clrscr ( );

cout << “GENERACIÓN DE 20 NÚMEROS ALEATORIOS ENTRE 50 Y 200 \n\n”;

randomize(); for ( int i = 0; i < 20; i ++) { /*Como se esta pasando la variable número mediante un parámetro por referencia, entonces la función mirandom esta trabajando sobre la variable original número*/ } mirandom (numero, 50, 200); cout << numero << end1; } getch ( ); }


102


103

CAPÍTULO V: RECURSIVIDAD

5.1 RECURSIVIDAD - Un algoritmo se dice que es recursivo cuando contiene en su

definición una o más llamadas a si mismo. - Todo algoritmo recursivo tendrá al menos una instrucción

alternativa. - La recursividad o recursión es una herramienta muy útil en la

resolución de problemas, ya que permite resolver problema complicados partiéndolos en problemas más sencillos.

EJEMPLO Nº 31 Función factorial

factorial(n: natural) dev f: natural IF n = 0 entonces // Condición de terminación f 1 // Caso base ELSE f n * factorial(n – 1) // Caso recursivo ENDIF

5.2 CARACTERÍSTICAS o Un algoritmo recursivo consta de una parte recursiva, otra

iterativa o no recursiva y una condición de terminación. o La parte recursiva y la condición de terminación siempre

existen.

Algo muy importante a tener en cuenta cuando usemos la recursividad es que es necesario asegurarnos que llega un momento en que no hacemos más llamadas recursivas. Si no se cumple esta condición el programa no parará nunca.


104

5.3 VENTAJAS Y DESVENTAJAS

Ventajas de la Recursión ya conocidas

Soluciones simples, claras.

Soluciones elegantes.

Soluciones a problemas complejos.

Desventajas de la Recursión: INEFICIENCIA

Sobrecarga asociada con las llamadas a subalgoritmos.

¿La claridad compensa la sobrecarga?

Una simple llamada puede generar un gran número de llamadas recursivas. (Fact(n) genera n llamadas recursivas).

El valor de la recursividad reside en el hecho de que se

puede usar para resolver problemas sin fácil solución iterativa.

La ineficiencia inherente de algunos algoritmos

recursivos.

5.4 PELIGROS EN LA RECURSIVIDAD Para decidir hacer un programa recursivo se deben de tener al menos dos cosas muy claras: o EL PASO BASE:

Esta es la clave para terminar la recursión, es cuando deja de hacer llamadas a la función recursiva y hace evaluaciones devolviendo los resultados. Además se debe asegurar de que es posible entrar a este paso.

o EL PASO RECURSIVO:

Es la parte de la definición que hace llamadas a esa misma función y que es la causante de las inserciones en la pila, almacenando en cada una de las llamadas, información del programa, del estado de sus variables locales y globales.

105

5.5 TIPOS DE ALGORITMOS RECURSIVOS

A. RECURSIÓN DIRECTA: Cuando un algoritmo se llama a si mismo en su definición.

A.1 RECURSIÓN LINEAL

Esquema general de una función recursiva lineal:

F(x: T1) dev r: T2 IF d(x) entonces r h(x) ELSE v F(s(x)) r c(x, v) ENDIF

Donde x:T1 y r:T2 son listas de parámetros y no un

único parámetro.

A.1.1 RECURSIÓN FINAL: Es una recursión lineal

donde lo último que se ejecuta es la llamada recursiva.

EJEMPLO Nº 32

Resto (n,m: N) dev r: N IF n < m entonces

r n ELSE

r Resto (n – m, m) ENDIF

-Lineal

- Múltiple- Anidada

REC. DIRECTA

REC. INDIRECTA

-Final- Lineal

106

A.1.2 RECURSIÓN LINEAL: Cuando sólo hay una

llamada recursiva en el algoritmo.

A.2 RECURSIÓN MÚLTIPLE

Cuando en la definición aparece más de una llamada

recursiva.

EJEMPLO Nº 33

Fib(n: N) dev f: N IF n <= 1 entonces f n ELSE f Fib(n – 1) + Fib(n – 2) ENDIF

A.3 RECURSIÓN ANIDADA Cuando alguno de los argumentos de la llamada es a su vez una llamada recursiva.

EJEMPLO Nº 34

Ack(n,m: N) dev ack: N

IF n = 0 entonces

ack m + 1

ELSE

IF m 0 entonces

ack Ack(n – 1, 1)

ELSE

ack Ack(n – 1, Ack(n, m – 1))

ENDIF

ENDIF


107

B. RECURSIÓN INDIRECTA: Cuando el algoritmo no tiene una llamada a si mismo, sino que llama a otro algoritmo que le llama a él.

EJEMPLO Nº 35

Funciones Par/Impar

- Impar (n: Nat) dev: p:bool IF n=0 p cierto ELSE IF n 1 p falso ELSE p impar(n-1) ENDIF

ENDIF

- Par (n: Nat) dev: p:bool IF n=0 p falso ELSE IF n 1 p cierto ELSE p par(n-1) ENDIF ENDIF

5.6 VERIFICACIÓN DE FUNCIONES RECURSIVAS

- Toda función recursiva contiene al menos una instrucción alternativa, por lo que la verificación consistirá en verificar instrucción alternativa.

- En una de las ramas de la instrucción alternativa vamos a tener una llamada a la propia función, pero para verificar una llamada una función, la propia función ha de estar ya verificada.

- La solución es aplicar el principio de inducción: Tomamos como Hipótesis de Inducción que la función ya está verificada para casos anteriores (para las llamadas recursivas).


108

5.7 LA PILA DE RECURSIÓN La memoria del ordenador se divide (de manera lógica, no física)

en varios segmentos (4):

Segmento de código: Parte de la memoria donde se

guardan las instrucciones del programa en código máquina.

Segmento de datos: Parte de la memoria destinada a

almacenar las variables estáticas.

Montículo: Parte de la memoria destinada a las variables

dinámicas.

Pila del programa: Parte destinada a las variables locales y

parámetros de la función que está siendo ejecutada.

5.8 LLAMADA A UNA FUNCIÓN RECURSIVA

En el caso recursivo, cada llamada genera un nuevo ejemplar de la función con sus correspondientes objetos locales

La función se ejecutará normalmente hasta la llamada a sí

misma. En ese momento se crean en la pila nuevos parámetros y variables locales.

El nuevo ejemplar de función comienza a ejecutarse.

Se crean más copias hasta llegar a los casos bases, donde se

resuelve directamente el valor, y se va saliendo liberando memoria hasta llegar a la primera llamada (última en cerrarse).


109

5.9 PARTE PRÁCTICA


1. Escribir una función recursiva Escribe Blancos(n) que imprima n

caracteres blancos consecutivos.

2. Escribir una función recursiva Invierte que acepte caracteres por teclado hasta recibir un retorno de carro y los imprima en orden inverso al de lectura. Los caracteres se leerán uno a uno y no deben almacenarse en un array; basta emplear una sola variable local a la función Invierte de tipo char.

3. Escribir una función recursiva que calcule el enésimo número de

Fibonacci.

4. Escribir una función recursiva Pascal(i,j) que calcule el elemento i, j del triangulo de Pascal, que sigue el siguiente patrón:

Como puede apreciarse, los elementos en el borde del triangulo son 1’s, y el resto de los elementos son iguales a la suma de los dos elementos que hay sobre ellos.

5. Escribir una función recursiva Palíndromo(c,i,j) que determine si la

subcadena contenida entre las posiciones i y j de la cadena c es un palíndromo.

110

LABORATORIO Nº 5 1. Función factorial recursiva

/* Función recursiva del factorial */ #include <stdio.h> long factorial( long numero ); /* prototipo de la función */ int main() {

int i; /* contador */ /* repite 11 veces; durante cada iteración, calcula el factorial( i ) y despliega el resultado */

for ( i = 0; i <= 10; i++ ) { printf( "%2d! = %ld\n", i, factorial( i ) ); } /* fin de for */ return 0;

} /* definición recursiva de la función factorial */ long factorial( long numero ) { if ( numero <= 1 ) { return 1; } else { /* paso recursivo */ return ( numero * factorial( numero - 1 ) ); } } /* fin de la función factorial */

111

• SERIE DE FIBONACCI

/* Función recursiva de fibonacci */ #include <stdio.h> long fibonacci( long n ); /* prototipo de la función */ int main() {

long resultado; /* valor fibonacci */ long numero; /* numero a introducir por el usuario */ /* obtiene un entero del usuario */ printf( "Introduzca un entero: " ); scanf( "%ld", &numero); /* calcula el valor fibonacci del número introducido por el usuario */

resultado = fibonacci( numero ); /* despliega el resultado */ printf( "Fibonacci( %ld ) = %ld\n", numero, resultado ); return 0;

} /* definición de la función recursiva fibonacci */ long fibonacci( long n ) {

/* caso base */ if ( n == 0 || n == 1 ) { return n; } else { /* paso recursivo */ return fibonacci( n - 1 ) + fibonacci( n - 2 ); }

}


112


113

CAPÍTULO VI: DATOS ESTRUCTURADOS

CONCEPTO

• Estructura de datos es una forma de organizar un conjunto de datos elementales (un dato elemental es la mínima información que se tiene en el sistema) con el objetivo de facilitar la manipulación de estos datos como un todo o individualmente.

• Una estructura de datos define la organización e

interrelacionamiento de estos, y un conjunto de operaciones que se pueden realizar sobre él.

• Las operaciones básicas son:

Alta, adicionar un nuevo valor a la estructura. Baja, borrar un valor de la estructura. Búsqueda, encontrar un determinado valor en la estructura

para realizar una operación con este valor, en forma SECUENCIAL o BINARIO (siempre y cuando los datos estén ordenados).

Ordenamiento, de los elementos pertenecientes a la estructura.

Apareo, dadas dos estructuras originar una nueva ordenada y que contenga a las apareadas.

6.1 TIPOS Los tipos de datos estructurados más comunes son: vectores y matrices (array), registros, cadenas de caracteres (string). ARRAY (ARREGLO) Es una estructura de datos en la cual se almacena una colección de datos del mismo tipo a este se le llama tipo base del arreglo, mientras que los datos individuales se llaman elementos del arreglo.


114

La declaración: int Array[10];

- Los elementos individuales del array se comienza a numerar a partir del elemento 0, así, Array[0] individualiza al primer elemento y Array[9] al último.

- Los arreglos pueden ser multidimensionales, así por ejemplo

double Matriz [10][20];

6.2 ARREGLOS UNIDIMENSIONALES, DECLARACIÓN Y ACCESO - Un arreglo unidimensional es un tipo de datos estructurado

que está formado por una colección finita y ordenada de datos del mismo tipo.

- El tipo de acceso a los arreglos unidimensionales es el acceso

directo, es decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o posteriores, esto mediante el uso de un índice para cada elemento del arreglo que nos da su posición relativa. Por ejemplo :

int edad [50];

edad [49]

edad [48]

edad [47]

.

.

.

.

edad [4 ]

edad [3 ]

edad [2 ]

edad [1 ]

edad [0 ]

edad [49]

edad [48]

edad [47]

.

.

.

.

edad [4 ]

edad [3 ]

edad [2 ]

edad [1 ]

edad [0 ]1

2

3

4

.

.

.

.

47

48

49

In d ice E lem en to

115

Esto reservará espacio en memoria para 50 números enteros ubicados en posiciones contiguas como puede observarse en la siguiente representación grafica. Declaración y asignación de valores a un arreglo. // declara un arreglo llamado estatura de tipo flota y tamaño 5

float estatura [5];

// Asignemos valores al arreglo de forma arbitraria

estatura [0]= 1.65;

estatura [1]= 1.57;

estatura [2]= 1.72;

estatura [3]= 1.80;

estatura [4]= 1.65;

Gráficamente el resultado es:

EJEMPLO Nº 36

Hacer un programa que registre 20 números en un arreglo unidimensional y muestre posteriormente los elementos que contienen los números múltiplos de 5 e imprima los elementos en forma inversa al ingreso de los datos.

#include <iostream.h> #include <conio.h>

estatura [4]1.65

estatura [3]1.80

estatura [2]1.72

estatura [1]1.57

estatura [0]1.650

1

2

3

4 estatura [4]1.65

estatura [3]1.80

estatura [2]1.72

estatura [1]1.57

estatura [0]1.650

1

2

3

4

Índice Contenido Elemento

116

int main() { int a[20]; int x = 0; // ADICIONO VALORES while (x < 20)

{ cout <<"Ingreso vector ["<< x+1 << "]: "; cin >> a[x]; x = x + 1; } x = 1; // MUESTRO ELEMENTOS while (x < 20){

if (a[x]%5 ==0) cout << "\n" << a[x]; x = x + 1; } cout << "\n"; getch(); }

EJEMPLO Nº37 Ingrese 10 notas en un arreglo de enteros y luego muéstrelo en pantalla

#include<iostream.h> #include<conio.h> int main() {

const int MAX=10; int notas[MAX]; for (int i=0;i<MAX; i++)

{ cout<<"Ingrese nota : "; cin>>notas[i]; } cout<<"\nFin de datos "; cout<<"\n\n Notas ingresadas"; for(int j=0;j<MAX; j++) { cout<<"\nNota [" << j + 1 << "] "; cout<<notas[j]; } getch ();

}

117

6.3 ARREGLOS BIDIMENSIONALES, DECLARACION Y ACCESO

Un array bidimensional (tabla o matriz) es un array con dos índices, al igual que los vectores que deben ser ordinales o tipo subrango.

Para localizar o almacenar un valor en el array se deben especificar dos posiciones (dos subíndices), uno para la fila y otro para la columna.

Formato:

EJEMPLO Nº 38 Diseñar un programa que permita ingresar valores en una matriz de 3 x 4 (lectura por columna)

#include<iostream.h> #include<iomanip.h> #include<conio.h> int main() { int num[4][3]; for (int a=0; a<4; a++){ for (int b=0; b<3; b++){ cout << "Número [" << b+1 << "], [" << a+1 << "] : "; cin >> num[a][b]; }

1. identificador = array [índice1, indice 2] of tipo de elemento2. identificador = array [ índice 1 ] of array [ indice 2 ] of tipo de

elemento

118

} cout << "\n\n"; for(int c=0; c<3; c++){ for(int d=0; d<4; d++) cout<< setw(5)<<num[d][c] << " "; cout << endl; } getch(); return 0; }

ARREGLO MULTIDIMENSIONAL

Se pueden describir como arreglos de arreglos.

Formato:

EJEMPLO Nº 39

#include <stdio.h> void imprimeArreglo( const int a[][ 3 ] ); /* prototipo de la función */ /* la función main comienza la ejecución del programa */ int main() {

/* inicializa arreglo1, arreglo2, arreglo3 */

int arreglo1[ 2 ][ 3 ] = { { 1, 2, 3 }, { 4, 5, 6 } }; int arreglo2[ 2 ][ 3 ] = { 1, 2, 3, 4, 5 }; int arreglo3[ 2 ][ 3 ] = { { 1, 2 }, { 4 } }; printf( "Los valores en el arreglo1 por linea son:n" ); imprimeArreglo( arreglo1 );

1. identificador = array [índice1] of array [índice 2]..of array [índice n] of tipo de elemento

2. identificador = array [índice 1, índice 2,...,índice n] of tipo de elemento

119

printf( "Los valores en el arreglo2 por linea son:n" ); imprimeArreglo( arreglo2 ); printf( "Los valores en el arreglo3 por linea son:n" ); imprimeArreglo( arreglo3 ); return 0; /* indica terminación exitosa */

} /* función para mostrar un arreglo con dos filas y tres columnas */ void imprimeArreglo( const int a[][ 3 ] ) {

int i; /* contador de filas */ int j; /* contador de clumnas */ /* ciclo a través de las filas */ for ( i = 0; i <= 1; i++ ) { /* muestra los valores de las columnas */ for ( j = 0; j <= 2; j++ ) { printf( "%d ", a[ i ][ j ] ); } /* fin del for interno */ printf( "n" ); /* comienza la nueva línea de salida */

} /* fin del for externo */ } /* fin de la función imprimeArreglo */

BÚSQUEDA EN ARREGLOS UNIDIMENSIONALES La Búsqueda Lineal o Secuencial consiste en el recorrido de todo el arreglo, desde el primer elemento hasta el último y de uno en uno. La intención es obtener el índice del elemento buscado puesto que con el índice se puede acceder al arreglo para obtener información sobre el elemento Considere al respecto un arreglo arreg de tamaño N, el pseudocódigo para la búsqueda es el siguiente:

120

indicebuscado =-1 PARA i=0 MIENTRAS i < N CON INCREMENTO 1

SI elemento buscado es igual arreg[1] ENTONCES indicebuscado = i; salir del bucle FIN_SI FIN_PARA

ORDENAMIENTO UNIDIMENSIONAL Existen diversas formas de ordenar un arreglo. En el curso se verá uno de los más simples y populares: Ordenamiento Burbuja o Bubble Sort.

ORDENAMIENTO BURBUJA O MÉTODO DE LA BURBUJA La Técnica de Ordenación por Burbuja consiste en ejecutar N-1 recorridos a lo largo del arreglo donde es cada recorrido se efectúan comparaciones entre elementos adyacentes intercambiando sus valores si están desordenados.

Pseudocódigo para ordenamiento ascendente.

EJEMPLO Nº 40

PARA i=0 MIENTRAS i<N-1 INCREMENTO 1 PARA j=0 MIENTRAS j<N-1 INCREMENTO 1 SI arreg[j] es mayor que arreg[j+1] ENTONCES intercambiar arreg[j] con arreg[j+1] FIN_SI FIN_PARA FIN_PARA

EJEMPLO Nº 41 Supóngase que desean ordenar las siguientes claves del arreglo A, transportando en cada pasada el menor elemento hacia la parte izquierda del arreglo. A: 15, 67, 08, 16, 44, 27, 12, 35

121

PROCESO DEL PROBLEMA

PRIMERA PASADA a[7]>a[8] (12>35) no hay intercambio a[6]>a[7] (27>12) si hay intercambio a[5]>a[6] (44>12) si hay intercambio a[4]>a[5] (16>12) si hay intercambio a[3]>a[4] (08>12) no hay intercambio a[2]>a[3] (67>08) si hay intercambio a[1]>a[2] (15>08) si hay intercambio

Luego de la primera pasada el arreglo queda de la siguiente forma:

A: 08, 15, 67, 12, 16, 44, 27, 35

Obsérvese que el elemento 08 fue situado en la parte izquierda del arreglo. Continuación se muestra el resultado de las siguientes pasadas:

3era. Pasada: 08 12 15 16 67 27 35 44 4ta. Pasada: 08 12 15 16 27 67 35 44 5ta. Pasada: 08 12 15 16 27 35 67 44 6ta. Pasada: 08 12 15 16 27 35 44 67 7ma. Pasada: 08 12 15 16 27 35 44 67

void Intercambio_Directo(int n) { int i,j,aux; i=0; j= n-1; for(;j>0;j--) for(i=0;i<j;i++) //recorre el arreglo de 0 a n-1 { if (arr[i]>arr[i+1]) /*si el elemento actual es mayor que el elemento siguiente */ { aux=arr[i]; //intercambio de elementos arr[i]=arr[i+1]; arr[i+1]=aux; } } }


122

6.4 REGISTROS

6.4.1 CONCEPTO Un registro es una colección de campos lógicamente relacionados, que pueden ser tratados como una unidad por algún programa. Un ejemplo de registro puede ser la información de un determinado empleado, que contiene los campos nombre, dirección, fecha de nacimiento, estudios, salario, trienios, etc.

Los registros pueden ser todos de longitud fija; por ejemplo, los registros de empleados pueden contener el mismo número de campos, cada uno de la misma longitud para nombre, dirección, fecha, etc. También pueden ser longitud variable. Los registros organizados en campos se denominan registros lógicos.

ARCHIVOS (FICHEROS) Un archivo o fichero es un conjunto de datos estructurados en una colección de entidades elementales o básicas denominadas registros o artículos, que son de igual tipo y constan a su vez de diferentes entidades de nivel más bajo denominadas campos, los cuales están organizados para un propósito especifico. Por ejemplo, un fichero de una clase escolar contiene un conjunto de registros de los estudiantes de esa clase, otros por ejemplo pueden ser el fichero de nominas de una empresa, inventarios, stocks, etc. Los datos están organizados de tal modo que pueden ser recuperados fácilmente, actualizados o borrados y almacenados de nuevo en el archivo con todos los cambios realizados.

6.4.2 DECLARACIÓN Y ACCESO

Para definir un tipo registro se utilizará la palabra reservada struct seguida del identificador del tipo y de la relación de componentes (tipo e identificador del componente terminado


123

en ';') entre llaves, terminada en ';'. A cada componente le llamaremos campo, y podrán ser de cualquier tipo (simple o compuesto).

Ejemplo

// tipo enumerado enum Meses { enero, febrero, marzo, abril, mayo, junio, Julio, agosto, septiembre, octubre, noviembre, diciembre }; // tipo registro struct Fecha { int dia; Meses mes; int anno; }; // variables Fecha f_nac ; Fecha f_ant;

No puede utilizarse el mismo identificador para especificar dos campos distintos de un mismo registro. Puede utilizarse el mismo identificador para especificar dos campos de distintos registros


124

6.4.3 ARREGLO DE REGISTROS Los arreglos y los registros pueden ser mezclados. Se puede tener un arreglo de estructuras, como se demuestra en el siguiente ejemplo.

EJEMPLO Nº 42

struct Registro { float unElemento; int unArreglo[10]; }; void fn() { struct Registro arrReg[20]; arrReg[10].unElemento=10.0; arrReg[10].unArreglo[5]=5; }

Los registros también pueden ser inicializados de la siguiente manera:

struct Registro { int primerElem; float segundoElem; }; void fn() { struct Registro simple = {1, 2.0}; struct Registro array[2] = { {1, 2.0}, /* array[0] */ {2,4.4}}; /* array[1] */ }


125

EJEMPLO Nº 43 En el ejemplo la estructura es Registro y el objeto es reg.

struct Registro { int primerElem; float segundoElem; } void fn()

{ struct Registo reg; reg.primerElem=0; /* se refiere al miembro entero */ reg.segundoElem=1.0; /* se refiere al miembro real */

}

6.5 CADENAS DE CARACTERES Una cadena (string) de caracteres es un conjunto de caracteres (incluido el blanco), que se almacenan en un área contigua de la memoria. Pueden ser entradas o salidas desde una computadora. Una Subcadena es una cadena de caracteres que ha sido extraída de otra de mayor longitud.

’12 de’ es una subcadena de ’12 de Octubre de 1492’ ‘como estás’ es una subcadena de ‘Hola, como estás?’ • Cadenas de Longitud Fija

Se consideran vectores de la longitud declarada, con blancos a izquierda o derecha si la cadena no tiene la longitud declarada.

Así el ejemplo siguiente: E S T A C A S A E S U N A R U I N A /// ///1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

Se declaró con una dimensión de 24 caracteres y los dos último se rellenan con blancos.


126

• Cadenas de Longitud Variable con un Máximo

Se considera un puntero, con dos campos que contienen la longitud máxima y la longitud actual.

20 17 E S T A C A S A E S G U A Y /// /// ///

Donde:

20 = Longitud máxima

17 = Longitud actual

Instrucciones Básicas con Cadenas

Las instrucciones básicas asignar y entrada/salida (leer/escribir) se realizan de un modo similar al tratamiento de dichas instrucciones con datos numéricos.

• Asignación

Si la variable NOMBRE ha sido declarada como carácter

var NOMBRE : carácter

La instrucción de asignación debe contener en el lado derecho de la asignación una constante tipo carácter (una cadena) o bien otra variable tipo carácter. Así:

NOMBRE: ‘Juan González’

Significa que la variable NOMBRE toma por valor la cadena ‘Juan González’

• Entrada/Salida

La entrada/salida desde una computadora se puede realizar en modo carácter, para ello se asignará una cadena de caracteres a una variable tipo cadena. Ejemplo:

var A,B,C,D: carácter

Las instrucciones:

READ A,B

WRITE C,D

127

Asignarán a A y B las cadenas introducidas por el teclado y visualizará o imprimirán en el dispositivo de salida las cadenas que representan las variables C y D.

EJEMPLO Nº 44

1. Calcula el numero de palabras en una cadena

#include <stdio.h> #include <conio.h> #include <string.h> void main() { //definición de variables char cadena[100]; int cont,contp=1; clrscr(); //limpia la pantalla printf("Cadena: ");gets(cadena); //obtiene la cadena

for(cont=0;cont<=(strlen(cadena)-1);cont++) { //recorre la cadena if(cadena[cont]==' ') //busca espacios contp++; //incrementa el conteo de palabras } printf("palabras: %d",contp);//salida en pantalla del resultado getch(); }

128

EJEMPLO Nº 45 Programa que cambia todas las minúsculas por mayúsculas

#include <stdio.h> #include <conio.h> #include <string.h> #include <ctype.h> int main() { char cadena[100]; int lon,car,cont; clrscr(); printf("Cadena: ");

gets(cadena); //obtenemos cadena lon=strlen(cadena); //obtenemos longitud

for(cont=0;cont<=lon-1;cont++) { car=cadena[cont]; //obtenemos el carácter en la posición cont if((car>=65)&&(car<=90))

{ //entonces es mayúscula cadena[cont]=tolower(cadena[cont]); //convertimos a minúsculas } }

printf("%s",cadena);//salida en pantalla de la cadena

getch(); }

129

EJEMPLO Nº 46

Programa que lee una cadena y la copia en otra de manera invertida

#include <stdio.h> #include <conio.h> #include <string.h>

int main() {

char cadena1[100],cadena2[100]; int longitud,cont,cont2=0;

clrscr();

printf("Cadena: ");gets(cadena1);//obtiene cadena 1

longitud=strlen(cadena1);

for(cont=longitud-1;cont>=0;cont--) { //recorre toda la cadena

cadena2[cont2]=cadena1[cont]; cont2++;

}

printf("%s",cadena2);//salida en pantalla de la cadena invertida getch(); }

6.6 PARTE PRÁCTICA

PROBLEMAS PROPUESTOS: 1. Diseñar un programa que lea dos vectores (arreglos

unidimensionales) A y B de N elementos, cada uno de tipo entero. Determine luego un vector C tal que sus elementos vengan dados por: C(0)=A(0)+B(N-1)=A(1)+B(N-2), C(2)=A(2)+B(N-3)…….., C(N-1)=A(N-1)+B(0). Imprima luego los tres arreglos en tres columnas paralelas, cada uno en una columna.

2. Diseñar un programa que ingrese los sueldos de 20 empleados de

una empresa en un arreglo y determine el menor sueldo, el sueldo total y sueldo promedio.

130

3. Diseñe un programa que ingrese los sueldos de N empleados de

una empresa en un arreglo unidimensional con capacidad máxima para 100 empleados. Imprima luego un listado de los sueldos superiores al sueldo promedio.

4. Diseñe un programa que lea 50 notas de un examen en un arreglo

unidimensional y determine: a) la nota promedio, b) la mayor nota, c) la menor nota, d) el numero de alumnos que comparten la menor nota y e) el numero de alumnos que compartan la mayor nota.

5. Diseñe un programa que ingrese un arreglo de N números enteros,

ordene el arreglo ascendentemente e imprima el arreglo ordenado. 6. Resuelva el problema 7; pero esta vez ordenado en forma

descendente. 7. Diseñe un programa que ingrese 15 letras del alfabeto, no

repetidas, a un arreglo unidimensional. Imprima luego el arreglo ingresado

LABORATORIO Nº 6

1. Diseñar un programa que ingrese 20 números enteros en un arreglo y determine: a). La suma de todos los elementos del arreglo y b). El número menor y su índice dentro del arreglo.

Solución: #include <conio.h> #include <iostream.h> int main ( ) { // Declaración de constantes y variables const int N = 20; // Número de personas int a [N]; // Arreglo de N números enteros int suma; // Suma de los elementos del arreglo int menor; // Menor valor de arreglo int indice; // Índice del menor valor dentro del arreglo int i; // Variable para los blucles for

131

// Ingreso de datos // En simultáneo ingresamos un elemento y lo vamos sumando clrscr ( ); cout << “INGRESO DE DATOS” << end1; suma = 0; for (i = 0; i < N; i++) { cout << “Ingrese elemento” <> a [i]; suma += a [i]; } // Hablamos el menor valor y su índice dentro del arreglo menor = a [0]; for (i = 1; i < N; i++) { if (a [i] < menor) { menor = a [i]; indice = i; } } // Salida de resultados cout << “\nSuma……………………...: ” << suma; cout << “\nNúmero menor……………: ” << menor; cout << “\nÍndice del número menor…: ” << indice; getch ( ); } 2. Diseñar un programa que ingrese dos arreglos, cada uno de 10

número enteros. Crear luego un tercer arreglo en la que cada uno de sus elementos sea la suma de los elementos correspondientes de los dos arreglos anteriores. Imprimir luego los tres arreglos en tres columnas paralelas.

Solución:

#include <conio.h> #include <iostream.h> #include <iomanip.h>

132

int main ( ) { // Declaración de constantes y variables const int N = 20; // Número de elementos de los arreglos int a [N], b [N], c [N]; // Los tres arreglos de N enteros int i; // Variable para los bucles for

// Ingreso de datos // A la vez que ingresamos vamos sumando clrscr ( ); cout << “Ingreso de datos” << end1; for (i = 0; i < N; i++) { cout << “a [“ <> a [i]; cout << “b [" <> b [i]; c [i] = a [i] + b [i]; } // Salida de resultados cout << “\nSalida de resultados\n”; cout << setw (4) << “a” << setw (4) << “b” << setw (4) << “c” << “\n\n”;

for (i = 0; i < N; i++) cout << setw (4) << a [1] << setw (4) << b [i] << setw (4) << c [i] << endl; getch ( ); } 3. Diseñar un programa que ingrese los sueldos de N empleados de

una compañía e imprima un listado de todos los sueldos inferiores al sueldo promedio. Considere que el sueldo mínimo es de S/.350. Validar todas las entradas.

Solución: #include <conio.h> #include <iostream.h> #include <iomanip.h>

133

void main ( ) { // Declaración de variables y constantes const int MAX = 50; // Máximo numero de empleados float suma; // Suma de los sueldos de los N empleados float promedio; // Sueldo promedio float sueldo [MAX]; // Arreglo de MAX sueldos (N debe ser menor o igual a MAX) int N; // Número de empleados int i; // Variable para los bucles for // Ingreso validado del número de empleados clrscr ( ); cout << “ Ingrese el número de empleados: ”; cin >> N; while (N < 1 || N > 50)

{ cout << “\aError. El número de empleados debe estar entre 1 y 50”; cout << “\nIngrese el número de empleados : ”; cin>>N; } // Ingreso validado del sueldo de cada empleado

for ( i=0; i<N; i++) { cout<< “ ¿ Sueldo del empleado “<> sueldo [i];

while (sueldo [i] < 350 ) { cout << “\aError. El sueldoMinimo es S/. 350”; cout << “\n ¿Sueldo del empleado “ <>sueldo[i]; } }

//hallamos el sueldo promedio suma=0;

for (i=0; i<N; i++) suma += sueldo [i]; promedio =suma / N;

134

// Salida de resultado cout << “\n Sueldo Promedio: “ << setprecision (2) << promedio; cout << “\n \n Lista de sueldos inferiores al sueldo promedio \n “; for (i=0; i<N; i++) { if (sueldo [i] < promedio ) cout << sueldo [i] << endl; } getch(); } 4. Diseñar un programa que lea los elementos de una matriz

cuadrada de 4 filas por 4 columnas compuestas de números enteros y determine:

• La suma de todos sus elementos • La suma de los elementos de la diagonal principal.

Solución: #include <iomanip.h> #include < iostream.h> #include < conio.h> int main () { const int TAM=4; // numero de filas y o de columnas (son iguales) int f, c; // fila y columna int a [TAM] [TAM]; // para la matriz int sumat, sumad; // suma total y suma de la diagonal

// Ingreso de la matriz por filas clrscr(); cout<<”Ingreso de una matriz de 4 x 4: “ <<endl; for ( f=0; f<TAM; f++) {

cout<<”Fila :” << f <<” : ”; for ( c=0; c<TAM; c++ ) cin >> a[f][c]; }

135

// Hallamos la suma total y la suma de la diagonal principal. // Observe que en la diagonal principal el índice f de la fila es igual que // el índice c de la columna. sumat = sumad = 0 ; for ( f=0; f<TAM; f++) { for ( c=0; c<TAM; c++) { sumat + = a[f] [c]; if ( f == c) // Si es un elemento de la

diagonal sumad + = a[f] [c];

} } // Imprimimos los resultados cout << “ \n Suma Total de elementos ………………: “ <<

sumat; cout << “ \n Suma de los elementos diagonales………: “ <<

sumad; getch();

}

5. Diseñar un programa que lea el siguiente arreglo bidimensional:

4 7 1 3 5 2 0 6 9 7 3 1 2 6 4

Y lo imprima como: 4 2 3 7 0 1 1 6 2 3 9 6 5 7 4 Solución: #include <iomanip.h> #include < iostream.h> #include < conio.h>

136

int main () { int A [3] [5], f, c;

// Ingreso del arreglo bidimensional por filas. clrscr(); cout<<”Ingreso de un arreglo bidimensional de 3 x 5: \n \n“; for ( f = 0; f < 3; f++) {

cout<<”Ingrese la Fila :” << f <<” en una linea: ”; for ( c = 0; c < 5; c++ ) cin >> A[f][c]; } // imprime según el esquema solicitado // esto lo logramos imprimiendo de salida \n\n “; cout<<”\n Impresión de salidas \n\n:” << f <<” en una linea:

”; for ( c = 0; c < 5; c++ ) { for ( f = 0; f < 3; f++) cout << setw (4) << A[f] [c]; cout << endl; } getch(); return 0;

}

6. Determina si dos cadenas son iguales o diferentes

Solución:

#include <stdio.h> #include <conio.h> #include <string.h>

137

int main() {

char cadena1[100],cadena2[100]; int cont; clrscr();

printf("Cadena 1: ");gets(cadena1); printf("Cadena 2: ");gets(cadena2);

for(cont=0;cont<=strlen(cadena1);cont++) { //recorremos

cadena 1

if(cadena1[cont]!=cadena2[cont]) //comparamos

printf("Desiguales"); //desiguales en caso de ke no sean iguales break; //cortamos si no son iguales

else if(cont==strlen(cadena2)) //seguimos

comparando printf("Iguales"); } getch();

}


138


139

BIBLIOGRAFÍA

BÁSICA: 1. JOYANES AGUILAR, LUIS (1998). Fundamentos de

Programación, Algoritmos y Estructura de Datos. Segunda Edición Mc Graw Hill.

2. LÒPEZ R., LEOBALDO. (1994). Programación estructurada: Un

enfoque algorítmico,. Computec. 3. LIPSCHUTZ, SEYMOUR (1987). Estructura de Datos. Me. Graw

Hill. Madrid 4. TENEBAUM / AUGESTEIN. Estructura de Datos en C. Prentice

Hall, México. 5. GILLES BRASSARD. Fundamentos de Algoritmia; Paul Bratley. 6. KRUSE, ROBERT L. Estructura de Datos y Diseño de Programas.

Prentice Hall, México. COMPLEMENTARIA: 1. WIRTH N. (1986). Algoritmos y Estructura de Datos. Edit. Prentice

may Hispanoamericana S.A. 2. VÁSQUEZ PARAGULLA, J. (1997). Diseño de Programación.

Tercera Edición. Editorial San Marcos. 3. BUSTOS FRANKLIN. Métodos de Programación. 4. ALCALDE EDUARDO & GARCIA MIGUEL. Metodología de la

Programación.

Algoritmos

Documents

Transcript of Algoritmos