ALGORITMOSAlgoritmo yy estructura de datos

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
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
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
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óndel
Problema
Especificacione
s de entrada
Especificacione
s de salida
Imprimir
múltiplos 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
Programa
fuente
Programa
Objeto
Programa
ejecutable
Compilador
(Compiler)
Montador
(Linker)
Programa
fuente
Programa
Objeto
Programa
ejecutable
Compilador
(Compiler)
Montador
(Linker)

21
EJEMPLO Nº 6
- CLASIFICACIÓN
TIPO
DE
DATO
DATOS SIMPLES
DATOS
ESTRUCTURADOS
ESTANDAR
DEFINIDOS X
EL PROGRAMADOR
NUMERICO
CHARACTER
LOGICO (BOOLEAN)
REAL
ENTERO
ENUMERATIVO
SUBRANGO
ESTATICOS
DINAMICOS
ARRAYS
REGISTRO
ARCHIVO (FICHERO)
LISTA (PILA/COLA)
LISTA ENLAZADA
CONJUNTO)
CADENA (STRING)
ARBOL
GRAFO
TIPO
DE
DATO
DATOS SIMPLES
DATOS
ESTRUCTURADOS
ESTANDAR
DEFINIDOS X
EL PROGRAMADOR
NUMERICO
CHARACTER
LOGICO (BOOLEAN)
REAL
ENTERO
ENUMERATIVO
SUBRANGO
ESTATICOS
DINAMICOS
ARRAYS
REGISTRO
ARCHIVO (FICHERO)
LISTA (PILA/COLA)
LISTA ENLAZADA
CONJUNTO)
CADENA (STRING)
ARBOL
GRAFO
DATOS
35.000 Soles
1250 unidades
José Perez Lima
83.000 Dólares.
3800 unidades
.......
PROCESAM IENTO
DE DATOS
INFORM ACIÓN
Cliente: José Perez
Sucursal: Lima
Compras del mes:
1250 unidades=35.000
Soles. ......
DATOS
35.000 Soles
1250 unidades
José Perez Lima
83.000 Dólares.
3800 unidades
.......
PROCESAM IENTO
DE DATOS
INFORM ACIÓN
Cliente: José Perez
Sucursal: Lima
Compras 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 DE
ENTRADA
ALGORITMO
DATOS DE
SALIDA
DATOS DE
ENTRADA
ALGORITMO
DATOS DE
SALIDA

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
RealRealDivisió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
RealRealDivisió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>
SignificadoOperador
Menor<
Distinto<>,!=
Mayor o igual>=
Menor o igual<=
Igual=
Mayor>
SignificadoOperador
disyunciónP o QOr
ConjunciónP y QAnd
NegaciónNot pNot
SignificadoExpresión lógicaOperador lógico
disyunciónP o QOr
ConjunciónP y QAnd
Negació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×montoT
MontoP =
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 PROGRAMA
Algoritmo de resolución
SALIDAENTRADA PROGRAMA
Algoritmo 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 ST R U C C IÓ N 1
IN ST R U C C IÓ N 2
.
.
.
IN ST R U C C IÓ N N
Acción 1
Acción 2
.
Acción N
Acción 1
Acción 2
.
Accion x
Acció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 enteron" ); /* indicador */
scanf( "%d", &entero1 ); /* lee un entero */
printf( "Introduzca el segundo enteron" ); /* indicador */
scanf( "%d", &entero2 ); /* lee un entero */
suma = entero1 + entero2; /* asigna el total a suma */
printf( "La suma es %dn", 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 le r í as t d li b .h
E n t r a d a / S a li d as t d i o .h
F u n c i o n e s m a t e m á t ic a sm a t h .h
L i m it 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 sl i m i t s .h
F l u j o d e e n t r a d a / s a li d ai o s t r e a m .h
F u n c i o n e s d e u t i le r í as t d li b .h
E n t r a d a / S a li d as t d i o .h
F u n c i o n e s m a t e m á t ic a sm a t h .h
L i m it 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 sl i m i t s .h
F l u j o d e e n t r a d a / s a li d ai o s t r e a m .h
BUCLE INFINITOBUCLE INFINITO
Suma = 0
INICIO
Leer N
Escribir suma
Suma
Suma + 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
inicio
fin
inicio
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:
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:
ESTRUCTURAESTRUCTURA
SELECTIVA SIMPLESELECTIVA SIMPLE
SELECTIVA DOBLESELECTIVA DOBLE
SELECTIVA MULTIPLESELECTIVA MULTIPLE
DDEE
SELECCIONSELECCION
condición
accionS1
verdadera
falsa
condició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ón
1 n
Acción
S1
Acción
S2
Acción
S3
Acción
S4
Acción
Sn
……
2 3
4
Condición
1 n
Acción
S1
Acción
S2
Acción
S3
Acción
S4
Acción
Sn
……
Condición
1 n
Acción
S1
Acción
S2
Acción
S3
Acción
S4
Acción
Sn
……
2 3
4

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 numeronn 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 <conio.h>

81
int main()
{
int numero=0;
do
{
numero= numero+1;
cout << “t” <<numero<<endl;
} while (numero <10);
cout <<"nt 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.

85
Submódulo “Imprimir totales”:
• Instrucciones de impresión de totales.
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 <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 <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 <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 <conio.h>
//Prototipo de la función múltiplo
int multiplo (int a, int b);
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 <conio.h>
// Prototipo de la función coutxy
void coutxy (int x, int y, char texto [ ] ) ;
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 <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 <conio.h>
// Prototipo de función
void mirandom (int& num, int min, int max);
int main ( )
{
int numero;
clrscr ( );
cout << “GENERACIÓN DE 20 NÚMEROS ALEATORIOS
ENTRE 50 Y 200 nn”;
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

ALGORITMOSAlgoritmo yy estructura de datos

ALGORITMOSAlgoritmo yy estructura de datos

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a ALGORITMOSAlgoritmo yy estructura de datos

Similar a ALGORITMOSAlgoritmo yy estructura de datos (20)

ALGORITMOSAlgoritmo yy estructura de datos