ALGORITMOS Y PROGRAMACION

Vista previa del material en texto

PRIMERA EDICIÓN, Enero de 2009 
SEGUNDA EDICIÓN, Enero de 2010 
corregida y aumentada. 
ALGORITMOS Y PROGRAMACIÓN 
Inga. Jenny M. Rodríguez . 
DERECHOS DE AUTOR REGISTRADOS ® 
Se pohibe su reproducción total o parcial 
por cualquier medio. 
G . ;a,A, C. A., 2010. 
AGRADECIMIENTOS 
A Dios, por todas las bendiiones rcibidas y or rcibir. 
A mis padrs y hemanos, por todo su amor y esmero. 
A mi hijo Sergio lván, regalo tan maravilloso que Dios me ha dado. 
A mis alumnos, me han enseñado a ser una mejor persona. 
INTRODUCCION 
La intención del presente libro, es la de presentar un texto práctio y sen�llo 
que ayude en los primeros pasos del aprendizaje de los algoritmos y la 
gramación. 
o deseo llenar dicho texto con demasiada teoría, mas bien con mucha
rácica aunque incluyo bastants explicacions. 
.n ste libro nos enfoaremos a la programación orientada a procedimientos 
y al lenguaje de programación C+, ya que dicho lenguaje es ideal para 
aliaciones cientíicas y nos permite entrar al ámbito tanto de la 
rogramación orientada a procedimientos omo de la programación 
oientada a objetos. 
n las bases de este libro, más adelante usted podrá profundizar en oros 
nguajes. 
eseo realcale que /a pgramación es una habilidad que adquirirá on 
mucha práctica. 
Espero que usted, que está iniciando en esta rama del aber, aprenda desde 
el pincipio que así como hay nom,as de calidad paa poducir alzado, 
medicinas, y otros productos, también hay nomas de alidad para prducir 
programas, y desde ya usted aprenda a elaborar programas con calidad, on 
excelencia. 
INDICE 
1. DEFINICIONES GENERALES ..................................................................... 1 
1.1. Las partes de un sistema de cómputo ............................................. 1 
1.2. Algoritmo .......................................................................................... 2 
1.3. Etapas en la solución de un problema ............................................ .4 
1.4. Características de un algoritmo ...................................................... .4
1.5. Programa ......................................................................................... 4 
1.6. Lenguajes de programación ............................................................ .4
1. 7. Tipos de Instucciones ..................................................................... 5 
1.8. Datos, tipos de datos ....................................................................... 5 
1.9. Memoria e identificadores ................................................................ 6 
1.1 O. La operación asignación ................................................................ 8 
1.11. Funciones intenas ......................................................................... 8 
1.12. Jerarquía de las operaciones matemáticas ................................... 9 
1.13. Expresiones aritméticas y algorítmicas ........................................ 12
1.14. Expresiones lógicas ..................................................................... 14
1.15. La operacón de declarar o definir ................................................ 17 
1.16. Mas acerca de la operación asignación ....................................... 18 
1.17. Ciclo de procesamiento de datos ................................................. 20 
1.18. Ejemplos de algoritmos ................................................................ 21 
1.19. Diagramas de flujo ....................................................................... 30 
2. PROGRAMACION EN C++ ........................................................................ 35 
2.1. Estructura general de un programa en c++ ................................... 35 
2.2. Estuctura típia de un programa en c++ ....................................... 35 
2.3. Tipos de datos en c++ .................................................................... 36 
2.4. Declaración de variables ................................................................ 36 
2.5. Declaración de constantes ............................................................. 37 
2.6. Caracteres secuenciales (códigos) de escape ............................ 38 
2.7. Entrada de datos ( cin ) .........•........................................................ 38 
2.8. Operadores y expresiones ............................................................ .43 
2.9. Librería conio.h ............................................................................. .45 
2.1 O. Funciones matemáticas .............................................................. .47 
3. ESTRUCTURAS SELECTIVAS O ALTERNATIVAS ( CONDICIONES ) ... 48 
3.1. Estructuras selectivas simples ...................................................... .48 
3.2. Estructuras selectivas compuestas o dobles ................................. 56 
3.3. Si ( if ) anidados o en cascada ....................................................... 67 
3.4. Altenativa múltiple o selección múltiple ........................................ 74 
4. ESTRUCTURAS REPETITIVAS (CICLOS, ITERACIONES, BUCLES) .... 84 
4.1. Ciclos mientras ( while ) ................................................................. 85 
4.2. Ciclos controlados por contador ..................................................... 88 
4.3. 
Acumuladores ................................................................................................ 93 
4.4. Ciclos controlados por centinela ( o bandera o lag ) ..................... 98 
4.5. Encontrando el menor y el mayor de los datos ingresados ......... 101 
4.6. Ciclos desde o para ( for ) ........................................................... 106 
4 7. Ciclos hacer-mientras ( do-while ) ................................................ 113 
4.8. Ciclos anidados ............................................................................ 122 
4.9. Librería stdlib.h ............................................................................. 128 
5. PROGRAMACION MODULAR ( FUNCIONES Y PROCEDIMIENTOS ).129 
5.1. Funciones intemas: ...................................................................... 131 
5.2. Procedimientos intenos ............................................................... 133 
5.3. Funciones deinidas por el usuario ( programador ) .................... 134 
5.4. Procedimientos ............................................................................ 142 
5.5. Recursividad ................................................................................ 147 
6. ESTRUCTURAS DE DATOS ..................................................... , ............. 150 
6.1. Arreglos o arrays unidimensionales ( vectores ) .......................... 1 SO 
6.2. Arreglos paralelos ........................................................................ 160 
6.3. Arreglos bidimensionales ( o matrices o tablas ) ......................... 167 
6.4. Matrices paralelas ........................................................................ 179 
6.5. Arreglos de más de dos dimensiones ( multidimensionales ) ...... 188 
6.6. Manejo de areglos utilizando funciones ...................................... 190 
6. 7. Cadenas de caracteres ................................................................ 195 
6.8. Esructuras o registros ................................................................. 202 
6.8.1 Estucturas ........................................................................ 202 
6.8.2. Estructuras anidadas ....................................................... 209 
6.8.3. Areglos de estructuras .................................................... 214 
6.8.4. Arreglos de estuctoras utilizando procedimientos .......... 219 
- 9. . • -cnivs ..................... _. ................................................................. 221 
5.9. 1. rchivos texto .................................................................. 221 
6.9.. hivos binarios ............................................................. 225 
! ,nos y Programación 
1. DEFINICIONES GENERALES
-iaremosnuestro estudio con algunas definiciones generales:
.1. LAS PARTES DE UN SISTEMA DE COMPUTO 
as·amente son cuatro: 
• hardware,
• software,
• datos y
• usuaios.
iARDWARE: 
O junto de componentes físicos de una computadora. Equipo físico. 
-.enplos: monitor, impresora, disco duro, etc. 
OFTWARE: 
1 
. ·unto de programas que controlan el funcionamiento de una computadora. ==-o lógico. 
=:nplos: dos, Windows, Word, etc. 
DATOS 
-nos o piezas individuales de información que por si mismos no tienen mucho
' ·do. El trabajo principal de una computadora es el de procesar estas
q eñas piezas de datos de distintas maneras convitiéndolas en información
>rlo tanto, INFORMACION implia datos procesados y organizados. 
USUARIO 
=s la persona que opera la computadora. Ninguna computadora es 
mpletamente autónoma. Las personas diseñan, construyen, programan y 
:oaran todos los sistemas de cómputo. 
Inga. Jenny M. Rodrfguez V. 
Algoritmos y Prgramación 2 
1.2. ALGORITMO 
Secuencia ordenada de pasos, sin ambigüedades, que conducen a la solución de 
un problema dado. 
Ejemplos de algoritmos de la vida diaria: 
Cambiar bombilla quemada en el techo: 
• Apagar interruptor,
• Adquirir bombilla adecuada y probada
• Acercar una escalera o silla y subirse con bombilla en mano
• Quitar bombilla quemada
• Colocar bombilla buena
• Bajarse
• Probar con interuptor,
• Limpiar y ordenar.
Elabore usted los siguientes algoritmos: 
• Cambiar vidrio roto de una ventana
• Cambiar llanta pinchada
• Poner la mesa para comer
• Preparar una taza de afé
• Preparar un pastel
Inga. Jenny M. Rodríguez V. 
gitmos y Programación 3 
.3. ETAPAS EN LA SOLUCION DE UN PROBLEMA 
a resolución de un problema con una computadora conduce a la escritura y 
�ción de un programa. 
• ,:es de escribir un programa, el programador debe entender el problema con
a ·dad, qué datos van a usarse, el resultado deseado y el procedimiento a
__ ar para producir este resultado.
_as fases o etapas de resolución de un problema con computadora son: 
• ANALISIS: El problema se analiza según los requerimientos de quien
solicita el programa.
• DISEÑO: Una vez analizado el problema, se diseña una solución que
conducirá a un algoritmo. En esta etapa se pueden utilizar herramientas
como Diagramas, pseudocódigo, etc.
• CODIFICACION ( IMPLEMENTACION }: El algoritmo lleva a escribir un
programa utilizando un lenguaje de programación.
• COMPILACION: El programa se compila, se eliminan los errores de sintaxis
que pudiera tener.
• EJECUCION Y VERIFICACION: Se comprueba que produzca los
resultados requeridos. Es importante ejecutar muchas veces el programa
con datos correctos y erróneos para detectar errores de lógica y que el
programa funcione como se requiere.
• DEPURACION Y MANTENIMIENTO: El programa se modiica cada vez
que el usuario lo requiera, ya que las necesidades de éste pueden variar
con el tiempo y _uso.
• DOCUMENTACION: Escritura de las diferentes fases del ciclo de v_ida del
software, principalmente análisis y diseño así como manuales de usuario y
de referencia así como normas para el mantenimiento.
Inga. Jenny M. Rodríguez . 
s y Prgramación 5 
TADUCTORES DE LENGUAJE 
o orogramas que traducen instrucciones de programas fuente de alto nivel a 
uaje máquina. Se dividen en Intérpretes y Compiladores. 
• Intérpretes: Traducen una línea, si no hay error la ejecutan y continúa así
con cada una de las siguientes líneas. Ejemplo: Basic.
• Compiladores: Traduce el total de todas las líneas, si hay error, despliega
un informe y no permite ejecutar nada sino hasta no encontrar ningún error
de sintaxis.
Ejemplo: c++, pascal.
.7. TIPOS DE INSTRUCCIONES 
• De entrada / salida
• Aitmético / lógicas
• Selectivas
• Repetitivas
• De principio/ fin
.8. DATOS, TIPOS DE DATOS 
e dividen en: 
• Numéricos Enteros (sin decimales)
Reales (manejan decimales) 
• Lógicos Verdadero (true) 
Falso (false) 
• Carácter a,b,c, ... A,B, C, ... (letras)
, *, @, /, ... (caracteres especiales)
1, 2, 3, ... (números utilizados como letras, no se pueden operar) 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Prgramación 6 
También los datos se pueden clasificar como:
• Constantes (no cambian su valor durante la ejecución de todo el programa),
y
• Variables (pueden cambiar de valor durante la ejecución del programa).
Y también se pueden clasificar como:
• 
!
Simple
! 
( consisten en una sola casilla de memoria ) y
• Estucturados ( conjunto de casillas de memoria como los arreglos ).
1 1 1 1 1 1 1 1 
1.9. MEMORIA E IDENTIFICADORES 
La memoria ram es semejante a una cuadrícula de millones de bytes. Al elaborar
un programa resevamos espacios de esta memoria para guardar datos y así
poder procesarlos por medio del programa. A estos espacios o celdas o casillas
de memoria se les asigna un nombre o identificador.
Un identificador es el nombre que se le da a las casillas de memoria a utilizar y se
'ona de acuerdo a las siguientes normas:
w. arácter que forma un identificador debe ser una letra (a, b, e, ...
3. -
2. _s ::a s ieres pueden ser letras(a, b, ... ), o dígitos(1,2, ... ) o guión
-':;-· 
3. � -_ -e:-- ce>e ser representativo del uso que se le dará
(--=.-.ó-:
Inga. Jenny M. Rodríguez .
gtmos y Programación 7 
�r ejemplo si declaramos la variable edad, resevamos 4 bytes en los que 
�rdaremos valores numéricos enteros, como: 28 ó 36 ó 59, etc. 
5 declaramos la variable nombre, resevamos unos 30 bytes para guardar 
adenas de caracteres como: Juan Pueblo. 
= declaramos la variable sueldo, resevamos 4 bytes para guardar valores 
a es como 3824.56. 
s· éeclaramos la variable x, no tendremos idea de lo que guardaremos en dicho 
siacio de memoria, por lo que evitaremos utilizar identificadores tan cotos y 
, . ,ién evitaremos identificadores tan largos como: fecha_de_nacimiento 
c¡ue tendemos a cometer errores y nos tardaremos mas tiempo en escribir 
:-:os caractres, lo ideal es utilizar entre 2 y 7 caracteres por nombre o 
� tific3dor. 
._ aeclarar dichas variables, en memoria se podrían representar así: 
Memoria AM 
-nbre 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Prgamacióñ B 
1.1 O. LA OPERACION ASIGNACION 
Después de haber declarado o definido o resevado la variable de memoria, ya 
podemos colocar datos en ella, utilizando la operación asignación, mediante el 
signo igual o mediante una flecha, así: 
Ejemplos: 
• edad= 23 ó 
• nombre = 'Juan Pueblo'
- /carácter)
• sueldo = 3824.56
• bandera = falso ó 
edad� 23 
ó nombre � 'Juan pueblo' 
ó sueldo � 3824.56 
bandera = 5 < 3 
(si es numérica) 
-(si es 
(si es lógica). 
Al asignar valor a dichas variables, en memoria se podría representar así: 
Memoria RAM 
edad 
ü 
nombre 
IJ I u la In I IP lu le lb 11 lo 1 
sueldo 
113824.56 I 
1.11. FUNCIONES INTERNAS 
Los lenguajes ontienen funciones matemáticas como: 
• ab(x); alula el valor absoluto de x
• s·,, x); alcula el seno de x ( en radianes )
• {x¡; c.uJa el oseno de x ( en radianes )
• :an[x ,; 2La la �angente de x ( en radianes )
• r �x:· ��o natural de x ( x>O )
• lg\x,1; ¿o >ase 10 de x ( x>O)
• ex(x ,; exc . .c' natural de x ( ex ) 
• sq{x); 2 a acrado de x ( square ( x2 ))
• sqt(x); se :a.-s � -aiz uadrada de x ( x>=O ))
• y muchas s -
Inga. Jenny M. Rodríguez V. 
qrfmos y Prgramación 
Ejemplos: 
• y= abs(-3); y vale 3, que es el valor absoluto de -3
• y= sqr(4); y vale 16, que es el cuadrado de 4
• x = sqrt{9); x vale 3, que es la raíz cuadrada de 9
• x = log(1 O); x vale 1, que es el logaritmo común de 1 O
• z = cos(0); z vale 1, que es el coseno de O
Ejercicios: 
.ál es el valor de x: 
. x = sin(0) 
2_ x = sqrt(9) + sqr(9) 
3. x = log(1) + ln(1) 
.. x = tan(0) + cos(0) 
5. x - abs(5) - exp(0) 
1• 2. JERARQUIA DE LAS OPERACIONES MATEMÁTICAS 
9 
s lenguajes se rigen por las mismas reglas prioritarias que la matemática, estas 
: 
• Signos de agrupación
• Exponentes y Radicales
• Multiplicación y División, Operadores div y mod
• Sumas y Restas
Operadores div y mod: 
• div: parte entera del cociente de la división
• mod:residuo de la división antes del punto decimal.
Inga. Jenny M. Rodríguez V.
Algoritmos y Prqramacióa 
Ejemplo: 
Al dividir 5 entre 3: 
Por lo tanto: 
x = 5 div 3; x vale 1 
_1_ �parte entera del cociente ( div) 
3 1 5 
2 ?residuo antes del punto decimal ( mod ) 
x = 5 mod 3; x vale 2 (residuo). 
x = 5/3; x vale 1.6667 ( incluye los decimales). 
Otro ejemplo: 
Al dividir 7 entre 2: 
Por lo tanto: 
x = 7 div 2; x vale 3 
y = 7 mod 2; y vale 1 
_3_ ?parte entera del cociente ( div) 
217 
1 ?residuo antes del punto decimal ( mod ) 
z = 7/2; z vale 3.5 ( incluye los decimales). 
Ejercicios: Resuelva los siguientes incisos, cuánto vale x ? 
• X = 15 div 4 
• X = 20 md 6 
• X = 50/6 
• x = 20v 3
• X = 20 d 3
JO 
Inga. Jenny M. Rodríguez V. 
� y Prgramación 
plos de jerarquía de operaciones: 
• X= 3 + 6 * 14
x = 3 + 84 (primero se multiplica, por último se suma) 
X= 87 
• x = -4*7+2"3/4-5
x=-4*7+ 8 /4-5
X = -28 + 2 - 5
X= -31
(primero el exponente) 
(después multiplicaciones y divisiones) 
(por último sumas y restas) 
. 11 
• x = 3+2* (18-4"2 )
agupación )
x = 3+2*(18-16)
x=3+2*2
( prime> el exponente dentro del signo de 
. ( signos de agrupación ) 
( multiplicación ) 
x = 3+4 ( por último sumas y restas ) 
x=7
• ¡ = 2° + 52 / 5 - 7 * 8
J = 1 +25/5 - 7 * 8
= 1 + 5 - 56 
! = -50
( primero los exponentes ) 
( multiplicaciones y divisiones ) 
( por último sumas y restas ) 
• : = 7 + 3 ** 5 -( 4 * 7 + 40 div 8 -36 mod 5 ) + 16 / 8 + 5
z = 7 + 243 - ( 28 + 5 1 ) + 2 + 5
z = 250 - 32 + 2 + 5
z = 225
• a = 5 b=4
¡=a * 2+b*4-( a*b+b*a )+b* 3/ a
= 5** 2+4*4-( 5*4+4* 5 )+4*3/ 5 
y = 25 + 16 - ( 20 + 20 ) + 12 / 5 
y = 25 + 1 6 -40 + 2.4 
y= 3.4 
i�rcicios: Resuelva los siguientes incisos, cuánto vale x ? 
• x = 16 * 6 -3 * 2 Respuesta: x = 90 
• x = ( 33 + 3 * 4 ) / 5 Respuesta: x = 9
• x = 2 " 2 * 3 Respuesta: x = 12 
• x = -22 Respuesta: x = -4 
• x = (-2)2 Respuesta: x = 4 
Inga. Jenny M. Rodríguez V.
Algoritmos y Programación 11 
1.13. EXPRESIONES ARITMETICAS Y ALGORITMICAS 
Expresiones aritméticas son las que vemos en nuestros libros de matemática. 
Expresiones algorítmicas son las que se utilizan en los programas para 
computadora. 
Las expresiones algorítmicas deben escribirse en una sola línea de caracteres, 
Todos los caracteres del mismo tamaño ( no subíndices ni superíndices ), 
Indicar siempre la multiplicación con un *, 
Indicar la división con una /, 
No utilizar símbolos como 1T, v, �. #, +. 
Ejemplos de expresiones aritméticas y algorítmicas 
• expresión aritmética: x = a2 + b2 algorítmica: x = a * a + b * b 
• expresión aritmética: x = _1�--­
y 
algorítmica: x = 1 / y 
• expresión aritmética: a = ( z + w) algorítmica: a= ( x /y)* ( z + w)
y 
a+­
c 
• expresión aritmética: y = __ algorítmica: y = ( a + b / c ) / ( d - e/ f )
d-g
f
ª2 b + ] 
• _ l=·- o-.sa: X = O 
Q - r Js 
q 
algorítmia: y = S.-E . - _, o)/ ( p / q - r" sqrt(s))
Inga. Jenny M. Rodríguez V.
os y Prgramación 13 
cicios: exprese en forma algorítmica las siguientes expresiones 
éicas 
• a= 5 ( z + w)
• d= m+n
p - q 
• x=_+p
n 
• b= x + v
u+ .
a 
• x=m + _n_ 
p-q
• a = r J ( 2 + h2 )
Inga. Jenny M. Rodríguez V.
\y 
Algoritmos y Programación 14 
1.14. EXPRESIONES LOGICAS 
Están constituidas por números, y operadores lógicos y/o relacionales. 
Su valor es siempre verdadero o falso, se utilizan para hacer comparaciones y 
condiciones en los algoritmos. 
Operadores relacionales: 
Permiten comparar dos operandos. El resultado es verdadero o falso, estos 
operadores son: 
Operador Relacional Signiicado 
< menor que 
> mayor que 
= igual que 
<= menor o igual que 
>= mayor o igual que 
<> distinto de 
Ejemplos de utilización de operadores relacionales: 
• Ejemplo: 1 < 5 verdadero 
• Ejemplo: 5 > 10 falso 
• Ejemplo: 5*3>10
15 > 10 
verdadero 
• Ejemplo: 2*4<3+1
8 < 4 
'also 
• Ejem>lo: a = 5 b = 16
ta�2 >(b*2 ) 
5�2 >( 16*2) 
25 > ( 32 ) 
'ao
Inga. Jenny M. Rodríguez V. 
s y Programación 15 
icios: encuentre el valor de las siguientes expresiones lógicas: 
· x = 2 y=3
e • 5 + y . 3 / 4 ) < = ( x . 3 div y ) respuesta: falso
0 mod 3 * 2 ** 4 ) > ( ( 15 * 2 ) = ( 60 * 2 / 4 ) ) respuesta: falso
• • 5 mod 4 * 3 >= 15 - 2*3
)
espuesta: verdadero
�- • 5 d 4 * 3 >= 15 - 2 ** 3 respuesta: verdadero
eradores lógicos: 
- :e, formular condiciones complejas a partir de condiciones simples, y son:
-_e no todos los lenguajes coinciden, la jerarquía de los operadores es la
_e�:e de mayor a menor: 
• Signos de agrupación
• =xponentes y radicales
• • ultiplicación;división, div, mod
• = <> < > <= >= . , ' , ' • o
• V
• o
- ; inuación se presenta la tabla de verdad de los operadores lógicos:
p a -P -a PoQ p A Q 
eladero verdadero falso falso verdadero verdadero
,:ladero falso falso verdadero verdadero falso
:also verdadero verdadero falso verdadero falso
:also falso verdadero verdadero falso falso
Inga. Jenny M. Rodríguez V. 
: 
Algoritmos y Programación 
Ejemplos de aplicación de operadores: 
• (1<5)Y(5<10)
V Y V 
verdadera 
• número= 5
( número = 1 ) O ( 7 >= 4 )
( 5 = 1 ) O ( 7 >= 4 ) 
falsa O verdadera 
verdadera 
• NO ( 15 >= 7 - 2 ) O ( 43 - e * 2 div 4 <> 3 * 2 div 2 )
NO ( 15 >= 49 ) O ( 43 - 16 div 4 <> 6 div 2 ) 
NO ( falso ) O ( 43 - 4 <> 3 ) 
NO (falso ) O ( 39 <> 3 ) 
NO ( falso ) O ( verdadero ) 
Verdadero O verdadero 
verdadero 
Ejercicios: resuelva los siguientes problemas. 
1_ 
1. ( 15 >= 7 * 3 - 2 Y 8 > 3 Y 15 > 6 ) O NO ( 7 * 3 < 5 + 12 * 2 div 3 ** 2 )
Respuesta: verdadero
2. NO ( ( 21 dv 2 • 4 ) > ( 15 / 2 * 6 >= 15 * 2 / 17 = 15 ) )
Reso"es:a: ro;, no se puede comparar un valor lógico y un numérico 
utiliza-ca _ 1 oerador relacional. 
Inga. Jenny M. Rodríguez V. 
mos y Programación 17 
-15. A OPERACIÓN DE DECARAR O DEFINIR:
.a der utilizar la memoia AM en un programa se declara o deine, esto nos
me resevar los espacios de memoria que utilizaremos para guardar los
� a procesar por nuestro programa.
emos deinir el tipo de dato ( entero, o real, o arácter o lógico ) que 
acar�mos ya que esto también implica el número de bytes de memoria a 
ar. 
--.iién debemos especificar el nombre o identificador de la variale siguiendo las 
as que vimos anteriormente. 
�to general para declarar una o varias variables es: 
tipo identiicador ( si es una sola vaiable) o
tipo identiicador1, identiicador2, ... , identiicadorN (si son varias 
ables) 
�nplos: 
• entero edad
• entero horas, nota
• -eal sueldo
• arácter letra
• lgico bandera
- -- a anterior secuencia de declaraciones resevamos memoria AM, la cual
o�taremos en la siguiente tabla:
horas nota sueldo letra bandera 
::,o dijimos antes, para poner datos adentro de las variables se utiliza la 
.-ación asignación. 
Inga. Jenny M. Rodríguez V.
Algoritmos y Prgramación 18 
1.16. MAS ACERCA DE LA OPERACIÓN ASIGNACION: 
La operación de asignación es el modo de almacenar valores en una variable, 
como ya vimos. 
La operación asignación se representa con el símbolo u operador� o el signo=. 
El formato general de una operación de asignación es: 
NombreVariable - expresión aritmética o lógica, ( o variable o
constante) 
La acción de asignar es destructiva, ya que si la variable contenía algún valor, 
éste se pierde y se conseva el último valor asignado. 
Ejemplo de asignación a las variable� antes declaradas: 
1. edad - 20 //almacena 20 en el espacio de memoria llamado edad.
2. edad � 15 // se pierde el valor anterior, se almacena el 15
3. edad - edad + 1 // como había un 15, al sumarle 1 se almacena 16
4. edad - edad -10 // como había un 16, al restarle 10 se almacena 6
5. edad - edad * 3 / 2//como había un 6,por 3 = 18 dividido 2,almacena 9
6. horas - 40 // se almacena 40 en variable horas
7. sueldo - horas * 15 // se almacena 600 en sueldo 
8. nota - 80 // se almacena 80 en nota 
9. letra � 'a' // se almacena letra a en variable letra 
10. bandera - 5 < 2// se almacena O= falso en variable bandera
A oninuación, tabla que muestra el resultado en memoria de las anterioresd---·=----·-·· 
No.Asignación edad horas nota sueldo letra bandera 
1 20 
2 15 
3 16 
� 6 
5 9 
6 1 40 
7 1 600 
8 1 80 
9 1 a 
10 1 o 
Inga. Jenny M. Rodríguez V.
mos y Prgramación 19 
cicios: En cada u no d e los siguientes incisos, cuál es el valor final? 
• a= 5 b= 10
a=a+b
a=a/3*2 *3
� =a I b
• X = 100 y= 2 
x = xmody**4 
¡=y**x 
• . =5 n =15 
,=m**2
= n*m+10 /5 
• a= 6 b =3
z =a* 2 +·b * 3-( a* b + b *a)+ b * 2 / a 
• \ = 5 B = 25 C = 1 O
X = A+B+C
X=A+B*C
X =A+B/C
X =A+ B mod C
X = ( A + B ) mod e
Inga. Jen:y M. Rodrfguez V. 
Algoritmos y Prgramación 20 
1.17. CICLO DE PROCESAMIENTO DE DATOS 
datos 
entrada •I proceso 
leer o read 
teclado 
salida ----� 
escribir o write (instrucción) 
monitor o impresora (dispositivo) 
entrada salida 
Aquí tenemos al usuario de un programa (la persona que lo está utilizando o 
ejecutando). 
El usuaio está ejecutando o corriendo un programa que está instalado en la 
computadora. 
El usuario introduce datos por medio del teclado, estos datos son 
almacenados en la meioria ram en celdas a las que se les da un nombre y un 
tipo. 
El programa uilza esos datos que el usuario ingresó, los procesa ( suma, resta, 
compara, ordna, e�c.l or medio del cpu de la computadora. 
El programa impime o despliega los datos ya procesados a traves del 
monitor o la impresora, a es:o se le llama salida. 
A grandes rasgos, en �.o ns�!e el ciclo de proceso de datos. 
Inga. Jenny M. Rodríguez V. 
! -: s y ramación 21 
EJEMPLOS DE ALGORITMOS 
l.0 de un algoritmo que sólo tiene salida: 
�·'Hola' (salida) 
10 despliega la palabra Hola en el monitor (utilizar la instucción 
�o n pantalla: 
ar la sangría en la instrucción escribir. Esto le da claidad al 
jemplo de un algoritmo que sólo tiene salida: 
bir 'Bienvenido a la programación' ( salid_a) 
c : ;omo despliega Bienvenido a la programación en el monitor. 
co en pantalla: 
-- - �e en pantalla no salen los apóstrofos. 
_ -;emplo de un algoritmo que sólo tiene salida: 
scibir 'Hoy es un hermoso día' (salida) 
s� :igoritmo despliega Hoy es un hermoso día en el monitor. 
:. :ado en pantalla: 
-: S un hermoso dia 
: oue en pantalla no salen los apóstrofos. 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Prgramación 
Ejercicios: 
• Escriba un algoritmo que despliegue su nombre en pantalla.
22 
• Escribir un algoritmo que despliegue su número de carnet y su número de
cédula.
• Escribir un algoritmo que despliegue su número de teléfono y su dirección.
• Escribir un algoritmo que despliegue sus tres comidas favoritas.
Ejemplo de un algoritmo que tiene entrada y salida. 
Entrada signiica que nuestro programa le pide un dato al usuario del programa, 
el valor que el usuario teclee como respuesta, ese será el valor que nuestro 
programa leerá y guardará en memoria. 
Necesitamos declarar una variable ( resevar un espacio en la mamaria ram) para 
guardar el dato que le pediremos al usuario, esta variable se llamará ed y 
almacenará un dato entero. 
inicio 
entero: ed 
escribir 'Ingrese su edad:' 
leer ed 
esibir 'Usted tiene' , ed, ·�ños' 
in 
(entrada) 
{salida) 
teior declara la variable entera ed, seguidamente se le despliega 
al usuao u, nensaje en pantalla Ingrese su edad, supongamos que el usuario 
responde tdea;,do un 20, el número 20 se almacena en la variable ed, en la 
siguien�e ·.s. . in, se despliega el mensaje: Usted tiene 20 años, finaliza el 
programa. 
Notar que ed o e esaf)e entre apóstrofos en la instrucción· escribir ya que no 
queremos des)..; '? iaabra ed sino el dato contenido en memoria en la 
variable ed. 
Inga. Jenny M. Rodríguez V. 
• e • : s y Programación 23 
ue el usuario teclea 20: 
a-os que el usuario ejecuta el programa por segunda vez. 
E 3=o anterior declara la variable entera ed, seguidamente se le despliega 
_ .-o n mensaje en pantalla Ingrese su edad, supongamos que el usuario 
_"n,:-e :cieando un 35, el número 35 se almacena en la variable ed, en la 
� .nstrucción, se despliega el mensaje: Usted tiene 35 años, finaliza el 
-- os las 2 corridas y simulemos 3 mas en la siguiente tabla:
-� Mensaje en Respuesta Variable Mensaje en 
pantalla del usuario ed pantalla ., Ingrese su edad: 20 20 Usted tiene 20 
años = Ingrese su edad: 35 35 Usted tiene 35 
años ,;, Ingrese su edad: 18 18 Usted tiene 18 años 
�. Ingrese su edad: 41 41 Usted tiene 41 
aios - Ingrese su edad: 57 57 Usted tiene 57 
años 
= �mos declarar una variable para cada dato que le pedimos al usuario. 
Inga. Jenny M. Rodríguez . 
, 
Algoritmos y Prgramación 24 
Otro ejemplo: 
Elaborar pseudoódigo que pida al usuario que ingrese temperatura y luego la 
despliegue. 
La temperatura puede contener decimales, por lo que la declaramos como real. 
inicio 
real: temp 
escribir 'Ingrese temperatura: 
-,leer temp 
escribir 'La temperatura es ' , temp, ' grados' 
fin 
(entrada) 
(salida) 
Resultado en pantalla suponiendo que el usuario teclea 32.5: 
Ingrese temperatura: 32.5 
La temperatura es 32.5 grados 
Resultado en pantalla suponiendo que el usuario teclea 35.1: 
Ingrese temperatura: 35.1 
La temperatura es 35.1 grados 
s 
co mensaje pantalla resp. variab. mensaje en pantalla 
usuario temo 
1 Ingrese temperatura: 32.5 32.5 La temperatura es 
qrados 
2 Ingrese temeratura: 35.1 35.1 La temperatura es 
grados 
32.5 
35.1 
3 Ingrese :em>era:ura: 40 40 La temperatura es 40 grados 
4 Ingrese :e�e:an. -a: 41.3 41.3 La temperatura es 41.3 
qrados 
5 Ingrese ter.,a� -a: 28.7 28.7 La temperatura es 28.7 
grados 
Inga. Jenny . Rodríguez V. 
3 -: s : rgramación 25 
u e eUdocódigo que pida al usuario que ingrese dos datos: dia y mes y 
s cspliegue. Ambos datos son enteros, no contienen decimales. 
-..o: di,me 
� 'Ingrese dia y mes: ' 
-di, e 
-=- · 'el dia es', di,' el mes es', me (entrada) (salida) 
ue el usuario teclea 24 12: 
variab. variab. mensaje en pantalla 
usuario di me 
mes: 24 12 24 12 El dia es 24 el mes es 12 
mes: 15 9 15 9 El dia es 15 el mes es 9 
mes: 28 2 28 2 El dia es 28 el mes es 2 
mes: 20 10 20 10 El dia es 20 el mes es 10 
mes:· 1 11 1 11 El dia es 1 el mes es 11 
Inga. Jenny M. Rodríguez V.
. 
Algoritmos y Prgramación 
Ejercicios: elabore un pseudocódigo: 
26 
• Que pida al usuario una nota entera y seguidamente se la despliegue.
• Que pida al usuario un salario real y seguidamente lo despliegue.
• Que pida al usuario un precio real y seguidamente lo despliegue.
• Que pida al Úsuario base y altura y seguidamente las despliegue
Ejemplo de un algoritmo que tiene entrada, proceso, salida: 
En el siguiente programa, le pediremos al usuario que ingrese su edad (por lo 
que debemos declarar una variable para almacenar el dato que el usuario 
ingrese), luego calcularemos la edad a la que se graduará sumándole 6 a la edad 
que ingresó antes (declaramos otra variable para guardar este cálculo), y 
posteriormentl desplegaremos el resultado de este cálculo. 
inicio 
entero: ed, grad 
escribir 'Ingrese su edad: 
leer ed 
grad = ed + 6 
escribir 'Se graduará a los', grad, 'años' 
fin 
(entrada) 
(proceso) 
< (salida) 
Supongamos que el usuano ingresa 18 como edad, ese 18 se guarda en la 
variable ed, seguidamente se le suma 6 ( 18 + 6 = 24 ), se guarda 24 en la 
variable grad, en la siguiente instrucción se despliega se graduará a /os 24 años. 
Resultado en pa,ta11a suponiendo que el usuario teclea 18: 
Ingrese su edao: 18 
Se graduará a los 24 años 
Inga. Jenny . Rodríguez V.
7 • . s y Programación 27 
entemos esta corrida simulemos otras 4 en la si uiente tabla: 
-e aje resp. variable variable mensaje en pantalla 
.talla usuario ed rad 
e edad 18 18 24 Se raduará a los 24 años 
21 21 27 Se raduará a los 27 años 
24 24 30 Se raduará a los 30 años 
30 30 36 Se raduará a los 36 años 
40 40 46 Se raduará a los 46 años 
.oocódigo se pudo haber escrito de la manera siguiente: 
.aremos la variable grad, no utilizaremos esta variable para guardar el =---�-,_-> el calculo, en cambio haremos el cálculo dentro de la instucción de 
.-:ero:ed 
Sroir 'Ingrese su edad: 
e· ed 
rDir 'Se graduaá a los : ed + 6, 'años' 
(entrada) 
( proceso y salida ) 
� -- a goritmo declaramos menos variables y escribimos menos líneas por lo 
.-"-a os memoria y el programa funciona igual que el anterior, por lo tanto, 
e -s e -ciente. 
oniendo ue el usuario teclea 18: 
esentemos esta corrida simulemos otras 4 en la si uiente tabla: - mensaje en resp. variable mensaje en pantalla -
antalla usuario ed 
18 18 Se raduará a los 24 años 
21 21 Se raduará a los 27 años 
24 24 Se raduará a los 30 años 
30 30 Se raduará a los 36 años 
40 40 Se raduará a los 46 años 
-.- :elante, utilizaremos este método cuando sea posible. 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Prgramación 2. 
Otro ejemplo: -.
El siguiente pseudocódigo pide al usuario kilos y los convierte a libras. 
Declaramos una constante de conversión, este valor no cambiará en todo el 
programa. 
inicio 
constante real conver = 2.2 
real: kil 
escribir 'Ingrese kilos: 
leer kil (entrada) 
escribir kil 'kilos equivale a ', kil * conver, 'libras' 
fin 
( proceso y salida ) 
Resultado en pantalla suponiendo que el usuario teclea 1 O: 
Ingrese kilos: 1 O 
1 O kilos equivale a 22 libras 
Tabla con la simulación de 5 corridas: 
corr consta mensaje en respue variab Mensaje en pantalla 
ida nte pantalla sta le kil 
conver usuario 
1 2.2 ingrese _kilos 10 10 1 O kilos equivale a 22 libras 
2 2.2 ingrese kilos 15 15 15 kilos equivale a 33 libras 
3 2.2 ingrese kilos 16 16 16 kilos equivale a 35.2 
libras _ 1 4 2.2 ingrese kilos 22 22 22 kilos equiyale a 48.4 
libras 
5 2.2 ingrese kilos 27 27 27 kilos equivale a 59.4 
libras 
Notar que la constante conver siempre tiene el mismo valor en todas las corridas 
y duran:e téa la orida del programa, no cambia, por eso se !lama constante. 
En un a1goiro sa pueden obviar algunos detalles como el mensaje ingrese 
klos, y sola.ene n-e- la instrucción leer kil. 
También el me,:_e ce salida puede ser más simple como escribir kil*conver y 
dejar los detalles .-a l irgrama final. 
Así lo haremos en el s�. .,:e jemplo: 
Inga. Jenny M. Rodríguez V. 
S L . y rgramación 
� a, al 
�a.al 
ba * al, 2 * ( ba + al ) 
o simulación de 5 corridas: 
1 1•=. s: 
1 1 
3 4 
10 5 
7 6 
15 20 
29 
base y altura de un rectángulo y 
(entrada) 
( proceso y salida ) 
área erímetro 
1 4 
12 14 
50 30 
42 26 
300 70 
�-R;-- � Seudocódigo de un programa que:
= : ólares y despliegue Quezales, declarar una constante de cambio. 
• =- " )_ gadas y despliegue centímetros (1 pulg. = 2.54 cms.). 
• >a ; ados Celsius y los convierta a Fahrenheit ( F = ( 9 / 5 ) C + 32 ).
• = -- ado de un cuadrado y despliegue área ( lado2 ) y perímetro ( 4 *lado ).
• = = -adio y despliegue diámetro, área y perímetro del círculo (diámetro= 2
��> área= T radio2 , pirímetro = 2 T radio).
Inga. Jenny . Rodríguez V. 
Algoritmos v Proqramacióa 30 
� 
1.19. DIAGRAMAS DE FLUJO 
Se utilizan para representar un algoritmo en forma gráica, algunos de los 
símbolos son: 
( inicio ) 
salida a 
pantalla 
� 
� 
e in ) /entrada/ proceso 
� 
� 
� 
- l 
t 
dire�ción 
- de flujo 
Un diagrama de flujo, también consta de entrada, proceso, salida así: 
inicio 
declaración de 
variables y constantes 
l / enirada / 
j proceso 1 
(salida) 
� 
Inga. Jenny . Rodríguez V. 
�:dol 
:-s�nte real cambio=8.2 
""bir 'Ingrese Dolares:' 
-dol 
roir 'Quezales = ' , dol * cambio 
real: dol 
constante real cambio=8.2 
/ dol / 
¡ < 'Quezales = ' , dol*cambio > 
onie� el usuario teclea 5: 
simulando 5 corridas del al oritmo: 
cambio dol 
8.2 5 
2 8.2 10 
3 8.2 75 
4 8.2 100 
5 8.2 250 
31 
Mensa·e antalla . 
Quezales = 41 
Quezales = 82 
Quetzales = 615 
Quezales = 820 
Quezales = 2050 
Inga. Jenny . Rodríguez . 
Algoritmos y Progamación J2 
Resolvamos el ejemplo de convertir pulgadas a centímetros, pseudocódigo y d.f.:
Pseudocódigo:
iniqio
real: pul
constante real cambio=2.54
escribir 'Ingrese pulgadas: '
leer pul
escribir 'Centímetros= ' , pul*ambio
fin
Diagrama de Flujo:
real: pul
( inicio)
¡ 
constante real cambio=2.54
/ pul/
l < 'Centímetros= ' , pul • cambio J 
Ingrese pu,gadas: 1
Centímetros = 254
i 
J 
Tabla con simulación de 5 corridas:
corrida cambio
1 1 2.54
2 1 2.54
3 1 2.1 
4 1 2.L 
5 1. 2 -,-�
pul Mensaje pantalla
1 Centimetros = 2.54
2 Centímetros = 5.08
5 Centímetros= 12.7
10 Centímetros = 25.4
50.5 Centímetros = 128.57
Inga. Jenny M. Rodriguez V. 
r. ramación 33 
• ,-s .m programa que pida dos números, luego alcule y despliegue la
:a y multiplicación de esos dos números que el usuario ingresó.
.1:-�o y d.f.:
� ,n2
�, - 'Ingrese dos números: '
"�·, n2
� • 'La suma es: ' , n1 + n2
�,· 'La resta es: ' , n1 - n2
�:"r 'La multiplicación es:', n1 * n2
real: n1, n2
/ n1, n2 /
¡ 
'La suma es: ' , n1 + n2
'La resta es: · , n1 - n2
'La multiplicación es: ' , n1 * n2
ue el usuario teclea 1 1 :
Inga. Jenny M. Rodríguez V.
Algoritmos y Prgamación 34 
Tabla con simulación de 2 corridas: 
corrida Mensaje pantalla n1 n2 Mensaje pantalla 
Ingrese dos números: 1 1 La suma es: 2 ., La resta es: O 
La multiplicación es: 1 
2 Ingrese dos números: 5 10 La suma es: 15 
La resta es: -5 
La multiplicación es: 50 . 
Ejercicios: 
Elaborar el diagrama de lujo de un programa que: 
• Pida grados Celsius y los convierta a Fahrenheit ( F = ( 9 / 5 ) C + 32 ).
• Pida lado d� un cuadrado y despliegue área ( lado2 ) y perímetro ( 4 * lado ).
• Pida radio y despliegue diámetro, área y perímetro del círculo ( diámetro= 2
radio, área= T radio2 , perímetro= 2 T radio) .
• Pida base y altura de un rectángulo y calcule y despliegue área ( base *
altura ) y parímetro ( 2 base + 2 altura ).
Inga. Jenny M. Rodríguez V.
, � amaión 
2. PROGRAMACION EN C++
RUCTURA GENERAL DE UN PROGRAMA EN C++ 
: --.cs de preprocesador (header files, librerías, bibliotecas) 
:_,:a ·ones globales (variables y constantes) 
2 : �on principal main( ) = r -es deinidas por el usuario 
..>-�ios del programa (utilizados en su totalidad) 
eader file, .h de c, .hpp de c++ 
onstantes y macros del procesador, no siempre se usa 
) / cabecera de la función 
::jue de sentencias, terminan con ; 
_Q DE UN PROGRAMA SENCILLO EN C++ 
_ -o.cpp. Programa de saludo. 
:,= -a imprime Bienvenido a la programacion C++ 
_: << "Bienvenido a la programacion C++\n"; 
35 
"= J programa codificado en c++ que despliegue su nombre en una línea y 
-e o de carnet en otra línea.
Inga. Jenny M. Rodríguez V. 
Algoritmos y Programación 
2.3. TIPOS DE DATOS EN C++ 
Básicamente son: 
• Enteros
• Coma flotantes (reales)
• Caracteres ( char)
• Lógicos (bool)
Tipo Eiemplo Tamaño (bytes) 
bool o 1
char 'C' 1
shot int -15 2
unsiqned int 325 4
int 1024 4
unsigned long 262144 4
long 2000000 4
float 10.5 4
double .00045 8
lonqdouble 1e" 10
2.4. DECLARACIÓN DE VARIABLES: 
36 
Ranqo(Min-Max) 
O . . 1 
-128 .. 127
-32768 .. 32767
0 . .4 2941967 295
-2147,483 648 .. 2147,483637
0 . .4 294,967 295
- 2147,483 648 . . 2147,483637
3.4*10° .. 3.4*1 oj 
1 . 7*1 o·O .. 1 . 7*1 O'º 
3 .4 *1 o,�,, •, 1 .1 *1 a-•�>L
ipoDato NombreVariable = Valorlnicial; 
Ejemplos: 
int valor; 
int valor1, valor2; 
int valor= 99; 
int num_parte = 1141, num_items = 45; 
float valor = 99. 99; 
char dato_car; 
char letra='A'; 
bool bisiesto; 
bool bisiesto=tr ue; 
bool b2=false; 
Inga. Jenny M. Rodríguez V.
37 
declarar constantes de dos maneras: utilizando #define o utilizando 
> 3.141593 // no signo igual, no ; 
onst TipoDato NombreConstante = ValorConstante; 
rt ,eses = 12; 
-a: arácter = '$'; 
=-sr int luna = 238857; // distancia en millas 
,_:<< "Distancia a la Luna"<< luna<<· millas\n"; 
-: ..na_kilo; 
-2 _ kilo = luna*1.609; // una milla = 1.609 kilometros
:_:<<"En Kilómetros es: • << luna_kilo << • kms.\n"; 
a a la Luna 238587 millas 
• --eiros es: 384320.913
Inga. Jenny M. Rodríguez V.
Algoritmos y Programación 38 
2.6. CARACTERES SECUENCIALES (CODIGOS) DE ESCAPE 
Código de Escape Signiicado 
'\n' Nueva línea 
'\r' Retomo decarro 
'\t' Tabulación horizontal 
'\v' Tabulación vertial 
'\a' Alerta (pitido sonoro) 
'\b' Retroceso de espacio 
'\f Avance de página 
2.7. ENTRADA DE DATOS (cin) (consola input) 
Ejemplo: 
#include <iostream.h> 
void main() 
{ 
} 
char primero, ultimo; 
cout << "Introduzca su primera y ultima inicial: "; 
cin >> primero >> ultimo; 
cout <<"Hola,"<< primero <<"."<< ultimo <<".!\n"; 
Salida a pantalla suponiendo que el usuario teclea C J: 
Introduzca su primera y ultima inicial: C J 
Hola C.J.! 
Simulemos esta v 4 corridas mas de este proorama en la síouíente tabla: 
corrí Mensaje en pantalla primero ultimo Mensaje en 
da pantalla 
1 intrduza su orimera y ultima inicial e j Hola C . J.! 
2 introauza s� oñmera y ultima inicial j R Hola J. R .! 
3 Intrduza su pl.era y ultima inicial A B Hola A . B.! 
4 introduza su piie:a y ultima inicial X X Hola X. X.!
5 introduza su pine-a y ultima inicial s M Hola S .M.! 
Inga. Jenny M. Rodríguez . 
r ramación 39 
mplos de programas que incluyen codificación en c++, 
s el ejemplo de convertir Celsius a Fahrenheit, pseudocódigo, d.f. y
Diagrama de Flujo:
- el 
� ·r 'Ingrese grados Celsius: '
-el
�:>·r 'Fahrenheit= ', (9 / 5) * cel + 32
(inicio)
t
real: cel
t 
/ cel /
t < 'Fahrenheit= ', ( 9 / 5 ) * cel + 32
·a: el;
_� << ªIngrese grados Celsius: ";
- >> cel;
_: << "Fahrenheit: "« ( 9 / 5 ) * cel + 32;
ue el usuario teclea 1:
rama: 
Mensa·e antalla 
Fahrenheit: 33.8
Fahrenheit: 50
Fahrenheit: 68
Fahrenheit: 122
Fahrenheit: 212
Inga. Jenny M. Rodríguez V. 
Algoritmos y Prgramación 4Q 
Resolvamos el ejercicio del cuadrado, pseudocódigo, d.f. y codificación en c++: 
Pseudocódigo: 
inicio 
fin 
real: lad 
escribir 'Ingrese lado: ' 
leer lad 
escribir 'Area= ' , lad * lad 
escribir 'Perímetro= ' , 4 * lad 
Codificación en c++: 
#include < iostream.h > 
void main () 
{ 
} 
float lad; 
cout << "Ingrese lado: "; 
cin >> lad; 
cout << "Area=" << lad * lad << endl; 
cout << "Perímetro= "<< 4 * lad; 
Diagrama de Flujo: 
inicio 
real: lad 
lad 
'Area= ' , lad * lad 
'Perímetro=' ,4 * lad 
fin 
Salida a pantalla suponiendo que el usuario teclea 1: 
Ingrese lado: 1 
Area= 1 
Perímetro= 4 
Tabla de simulación de 5 corridas: 
c orrida Mensaje 
pantalla 
1 Ingrese lado: 
2 Ingrese lado: 
3 1 Ingrese lado:i1
A 
1 Ingrese lado:
5 1 1 1 Ingrese lado: 
lad Mensaje pantalla 
1 Area= 1 
Perímetro= 4 
5 Area= 25 
Perímetro= 20 
7 Area= 49 
Perímetro= 28 
12 Area= 144 
Perímetro= 48 
23 Area= 259 
Perímetro= 92 
Inga. Jenny M. Rodríguez V.
nte real pi=3.141593 
.-ad 
-,· 'Ingrese radio: ' 
-ad 
-,·· 'Area=', pi* rad * rad 
: · 'Perímetro= ' , 2 * pi * rad 
: "at pi = 3.14159; 
o; 
J • << 'Ingrese radio: "; 
- >> -ad; 
Diagrama de Flujo: 
inicio 
constante real pi=3.1411593 
real: rad 
rad 
'Diámetro= ' , _2 * rad 
'Area= ' , pi * rad * rad 
'Perímetro=' . 2 *pi* rad 
fin 
: << 'Diametro= • << pi * rad * rad << endl; 
: << ·Area= " << pi * rad * rad << endl; 
:<< "Peri metro= • << 2 * pi * rad; 
: "!. 593 
----=- 5.283184 
e s·mulación de 2 corridas: 
41 
pi Mensaje rad Mensaje pantalla 
antalla 
3.141593 · Ingrese radio: 1 Diámetro: 2 
3.141593 Ingrese radio: 
Area: 3.141593 
Perímetro: 6.2831 
5 Diámetro: 2 
Area: 78.5398 
Perímetro: 31.415 
Inga. Jenny M. Rodrfguez . 
Algoritmos y amación 42 
Ejercicios: Elaborar pseudocódigo, diagrama de flujo y codifiación en c++ de 
programa: 
• Que pida al usuario que ingrese kilos. El programa debe calcular y
desplegar el equivalente a libras así: 1 kilo= 2.2 libras.
• Que pida al usuario 3 números reales y alcule y despliegue la suma y el
promedio de dichos números
Inga. Jenny M. Rodríguez V. 
ramación 
de Asignación abreviados: 
asignación 
abreviada 
m += n 
m-=n 
m*=n 
m/=n 
mo=n 
* 
asignación 
no abreviada 
m= m+n 
m=m-n 
m = m*n 
m = m / n( cociente) 
m = m % n(residuo) 
() 
Decrementación 
--n
- =- - .
n-=1 
n=n-1 
43 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Programación 
Operadores Relacionales: 
Operador 
!= 
> 
< 
>= 
<= 
Operadores Lógicos: 
Y ( and ): && 
O (ar): 11 
NEGACIÓN (not): 
Significado 
igual a 
no iguala 
mayor que 
menor que 
mayor o igual a 
menor o igual a 
Ejemplo 
a==b 
a!= b 
a>b
a<b 
a>= b 
a<= b 
44 
Inga. Jenny M. Rodríguez . 
e ramación 
RIA conio.h ( consola input/ output) 
• Scr( ); // borrar pantalla, deja el cursor en posición 0,0
45 
• ireol( ); // borra línea actual desde posición actual al final de la línea
• cprintf( ); // escribe salida con formato en consola (salto= \r\n )
• sanf( ); // lee caracteres con formato desde la consola
• celline( ); // borrar línea completa actual, y desplazar hacia arriba
as líneas que haya debajo
• getch( ); // lee un carácter sin eco desde la consola
• �etche( ); // lee un carácter con eco desde la consola
• �etpass( ); // lee password que no se visualiza ( 8 caracteres )
• gotoxy(int c, int f); // mueve cusor a posición c (columna), f (fila)
• ighvideo( ); // activa caracteres de alta intensidad
• - port, inportb // leer desde puetos de entrada/salida
• - sline( ); // inserta línea en blanco en la posición del cursor
• ovideo( ); // activa caracteres de baja intensidad
• ,ormvideo( ); // reinicializa atributos de texto a valores originales
• outport, outportb // escribe en pueto de entrada/salida
• textbackground( int #color ); // color de fondo
• !extcolor( int #color ); // color de texto visualizado por cprinf y csanf
• 1here( x ); //devuelve coordenada x (columna) de la posición actual
del cursor 
• where( y ); //devuelve coordenada y (fila) de posición actual de cursor
colores: O: negro -> 15: blanco 
ormatos: cprintf y cscanf: 
código: formato: 
�ic carácter 
%d entero decimal 
¾e real ( double o float ), notación científica 
of-' \flotante 
%i entero 
os cadena de caracteres (string) 
ox hexadecimal sin signo 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Programación 
// probando algunas funciones de libreria conio ... 
#include <iostream.h> 
#include <conio.h> 
main( ) 
{ 
cout << "probando libreria conio ... " << endl; 
getch(); 
textbackground(1 ); clrscr( ); // color de fondo 
cout << "probando textbackground ... " << endl; 
getch( ); 
46 
textcolor(2); cout << "probando textcolor ... no funciona con cout" << endl; 
getch( ); 
} 
cprintf("probando cprintf ... \n\r"); 
getch( ); 
float n1=3.141593; 
int n2=10; 
cprintf("123456789+123456789+123456789+123456789+123456789+\\n"); 
cprintf("EI producto de %10.6f * %5i = %15.8F,n1 ,n2,n1 *n2); 
getch( ); 
char dia; 
gotoxy( 20,20 ); cprintf("ingrese dia: "); 
cscanf("%c:",&dia); 
cprintf(\n\rEI dia ingresado es %c \n\r",dia); 
cout << "Usted ingreso el día: " << dia << endl; 
getch( ); 
getch( ); 
Teclee y ejecute el programa anterior y podrá obsevar cómo trabajan algunas de 
las funciones de la librería conio.h 
Inga. Jenny M. Rodríguez V.
• 
mación 
JONES MATEMÁTICAS 
bcd.h, complex.h, float.h, math.h, stdlib.h 
LIBRERÍA math.h 
· ones Matemáticas:
{ x ) // valor absoluto de x 
x ) // redondea al entero superior 
=o{ x ) // redondea al entero mas próximo 
�( x, y ) // residuo de x/y 
, x, y ) // potencia: xY 
=1( x ) // raíz cuadrada de x ( x >= O ) 
·ones Trigonométricas:
�- ( x) // seno de x (radianes) 
S( x ) // coseno de x 
:n( x) // tangente de x 
asín( x ) // arco seno de x 
aos( x ) // arco coseno de x 
;:an( x ) // arco tangente de x 
:Oh( x) // seno hiperbólico de x 
osh( x ) // coseno hiperbólico de x 
:anh( x ) // tangente hiperbólica de x 
- : _nciones Logarítmicas y Exponenciales:
exp( x ) // exponencial natural de x ( ex ) 
log( x ) // logaritmo natural de x ( x > O ) 
log10( x) // logaritmo base 10 de x ( x >O) 
• Otras:
hy pot(x,y) // calcula hipotenusa con catetos x, y 
47 
Inga. Jenny M. Rdríguez .
Algoritmosy Pogramación 
Codificación en C++: 
#include <iostream.h> 
#include <conio.h> 
void main() 
{ 
int mat[ 2 ][ 3 ] , f ,c; 
for( f = O; f < 2; f++ ) // ciclos para llenar matriz 
far( c = O; c < 3; c++ ) 
mat[ f] [ c] = O; 
far(f = O; f < 2; f++ ) // ciclos para imprimir matriz 
{ 
far( c ; O; c < 3; c++ ) 
171 
cout << mat[ f] [ c] « ". "; imprime casilla y deja espacio 
cout << endl; // salto de linea al terminar de desplegar las columnas 
} 
getch( ); 
} 
Resultado en pantalla: 
I º º º o o o
· Tabla simulando la corrida del anterior programa, primer par de ciclos
llenando mat:
Corrida f c mat[ f ] [ e ] = O 
1 o o mat[ O 1 [ O 1 = O 
1 mat[ O ][ 1 ] = O 
2 mat[ O ] [ 2 ] = O 
1 o mat[ 1 ] [ O J = O 
1 matf 1 l í 1 l = O 
2 mat[ 1 ][ 2 1 = O 
El resultado en memoria será un cero en cada casilla de la matriz: 
! mat Columna O Columna 1 Columna2 
1 Fila O o o o 
i Fila 1 o o o 
Inga. Jenny M. Rodríguez V.
Algoritmos y Programación 172 
Otro ejemplo: 
Veremos un programa que declara una matriz de 5 filas por 5 columnas, enteras, 
se desea llenar dicha matriz con números aleatorios entre O y 49; para mayor 
claridad del programa, se imprimirá en otro par de ciclos diferentes de los 
utilizados para llenar la matriz. 
Pseudocódigo: 
inicio 
in 
entero: mat[ 5 ] [ 5 ], f , c 
para f desde O hasta 4 paso 1 hacer 
para c desde O hasta 4 paso 1 hacer 
mat[ f ] [ e ] = random( 50 ) 
fin_para 
fin_para 
para f desde O hasta 4 paso 1 hacer 
para c desde O hasta 4 paso 1 hacer 
escribir mat[ f) [c) 
fin_para 
finpara 
inicio 
Diagrama de Flujo: 
entero: mat[ 5 ] [ 5 ], f, c 
f = O, 4, 1 
c = O, 4, 1 
mat[ f] [ e] = random( 50 ) 
f = O, 4, 1 
e= O, 4, 1 
mat[ f ][ c] 
in 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Programación 
Codificación en C++: 
// mataleatorios.cpp llenando matriz con numeras aleatorios 
#include <iostream.h> 
#include <conio.h> 
#include <stdlib.h> 
void main() 
{ 
int mat[ 5 ] [ 5 ], f, c; 
randomize( ); 
for( f = O; f < 5; f++ ) 
for( c = O; c < 5; e++ ) 
173 
mat[ f] [ e] = random( 50 ); // llenando matriz con números aleatoris 
for( f = O; f < 5; f++ ) 
{ -
o r ( e = O; e < 5; e++ ) 
cout « mat[ f] [e]« " "· // imprimiendo matriz 
cout << endl; 
} 
getch( ); 
} 
Resultado en pantalla: 
43 9 23 12 24 
17 24 23 22 2 
7 30 20 25 36 
37 36 6 5 26 
28 33 12 35 5 
Inga. Jenny . Rodríguez . 
. 
Algoritmos y Programación 174 
1 
1 
! 
1 
1 
: 
i 
1, 
:,: 
Tabla simulando la corrida del anterior programa, 
llenando mat con números aleatorios entre O v 49: 
Corrida f e 
1 o o 
1 
2 
3 
4 
1 o 
1 
2 
3 
4 
2 o 
1 
2 
3 
4 
3 o 
1 
2 
3 
4 
4 o 
2 
3 
4 
primer par de ci 
mat[ f] [e]= 
random( 50) 
matf O] O 1 = 43 
matf O] 11 = 9 
mat[ O l 2 l = 23 
mat[ O] 31=12 
matf O ] 4 1 = 24 
matf 1 l O 1 = 17 
matf 1 l 1 1 = 24 
matf 1 1 2 l = 23 
matf 1 l 3 l = 22 
matf 1 1 41 = 2 
mat[ 2 l O]= 7 
matf 2 l 1] = 30 
mat[ 2 ] 2 J = 20 
mat[ 2 ] 3 1 = 26 
matf 2 1 f 4 1 = 36 
matf 3 1 O 1 = 37 
matf 3 l f 1 ] = 36 
mat[ 3] 2] = 6
mat[ 3] 3]= 5
mat[ 3 J 4 ] = 26 
matf 4 ] f O 1 = 28 
matf 4] 1l =33 
matf 4 1 f 2 l = 12 
matf 4 1 f 3 l = 35 
matf 4 l 4] = 5 
clos 
El esultado en memoria será un número aleatorio entre O y 49 en cada casill a de 
la matriz: 
mat Columna Columna Columna Columna Columna 
o 1 2 3 4 
Fila O 43 9 23 12 24 
Fila 1 17 24 23 22 2 
Fila2 7 30 20 25 36 
Fila 3 37 36 6 5 26 
Inga. Jenny M. Rdríguez .
Algoritmos y Programación 175 
Otro ejemplo: 
Veremos un programa que declara una matriz de 2 ilas por 3 columnas, enteras. 
se desea llenar dicha matriz con datos ingresados por el usuario; para mayor 
claridad del programa, se imprimirá en otro par de ciclos diferentes de los 
utilizados para llenar la matriz. 
Pseudocódigo: 
inicio 
fin 
entero: mat[ 2] [ 3 ], f, c 
para f desde O hasta 1 paso 1 hacer 
para e desde O hasta 2 paso 1 hacer 
escribir "Ingrese valor·, f, • ,", c, ":" 
leer mat[ f] [ c ] 
fin_para 
fin_para 
para f desde O hasta 1 paso 1 hacer 
para e desde O hasta 2 paso 1 hacer 
escribir mat[ f] [c ] 
fin_para 
fin_para 
inicio 
Diagrama de Flujo: entero: mat[ 2] [ 3 ], f, 
f = O, 1, 1 
c = O, 2, 1 
mat[ f][ c] 
f = O, 1, 1 
c = O, 2, 1 
mat[ f ][ c] 
fin 
Inga. Jenny M. Rodríguez .
Algoritmos y Programación 
Codiicación en C ++: 
// matusuario.cpp llenando matriz con datos ingresados por usuario 
#include <iostream.h> 
#include <conio.h> 
void main() 
{ 
int mat[ 2 J [ 3 1, f, e; 
far( f = O; f < 2; f++ ) 
far( e = O; e < 3; e++ ) 
{ cout << "Ingrese valor"<< f << ","<<e<<":"; 
cin » mat[ f] [ e J;
} 
far( f = O; f < 2; f++ ) 
{ 
} 
far( e = O; e < 3; e++ ) 
cout << mat[ f] [e]«" "· 
cout << endl; 
getch( ); 
} 
Resultado en pantalla: 
lnmese valor O O: 1 O 
Ingrese valor O 1 : 20
Ingrese valor O 2: 30
Ingrese valor 1 O: 40
Ingrese valor 1 1: 50 
Ingrese valor 1 2: 60
10 20 30 
40 50 60 
176 
Inga. Jenny M. Rodríguez V.
Algoritmos y Programación 177 
Tabla simulando la corrida del anterior programa 
Corrida f e Usuario 
1 o o 10 
1 In 20 
2 In 30 
1 o In 40 
1 In 50 
2 In 60 
El resultado en memoria 
mat Columna O Columna 1 Colm,ma2 
Fila O 10 20 30 
Fila 1 40 50 60 
Inga. Jenny M. Rodríguez . 
Algoritmos v Programación 178 
Ejercicios: 
Elaborar pseudocódigo, diagrama de flujo y codificación en c++ de un programa 
que: 
1. Declare una matriz entera de 4 filas por 4 columnas. En la fila O, poner O en
todas las columnas, en la fila 1, colocar 1 en todas las columnas de esa fila,
y así sucesivamente. Imprimir matriz.
2. Declare una matriz entera de 1 O filas por 1 O columnas. Llenar la matriz con
las tablas de multiplicar. Imprimir matriz.
3. Declare matriz de 24 filas por 3 columnas, en la que se guardarán las
temperaturas menor, mayor y promedio ingresadas por el usuario ( en las 3
columnas ), de cada hora de un día ( filas ), las temperaturas pueden
contener decimales. Imprimir la matriz.
Inga. Jenny M. Rodríguez V. 
Algoritmos y Programación 179 
6.4. MATRICES PARALELAS: 
Se refiere al manejo simultáneo de dos o mas matrices como en los siguientes 
ejemplos: 
Ejemplo: 
Ahora trabajaremos con 3 matrices de 4 filas por 4 columnas, mat1, mat2, mat3; 
llenaremos las 2 primeras con números aleatorios y la tercera será la suma de las 
dos primeras: 
Pseudocódigo: 
inicio 
fin 
entero: mat1[ 4] [ 4 ], mat2[ 4] [ 4 ], mat3[ 4] [ 4 ], f, c 
para f desde O hasta 3 paso 1 hacer 
para c desde O hasta 3 paso 1 hacer 
mat1 [ f ][ c ] = rand( 1 O ) 
mat2[ f] [ c ] = rand( 1 O ) 
mat3[ f] [ c ] = mat1 [ f J [ c ] + mat2[ f ] [ e ] 
fin_para 
fin_para 
para f desde O hasta 3 paso 1 hacer 
para c desde O hasta 3 paso 1 hacer 
escribir mat1 [ f J [c] 
fin_para 
escribir espacio 
para c desde O hasta 3 paso 1 hacer 
escribir mat2[ f J [ e ] 
fin_para 
escribir espacio 
para e desde O hasta 3 paso 1 hacer 
escribir mat3[ f J [ e ] 
fin_para 
escribir salto de línea 
in_para 
Inga. Jenny M. Rodríguez V.
Algoritmos y Progamación 
Diagrama de Flujo: 
inicio 
entero: mat1[ 4] [ 4], mat2[ 4] [ 4 ], mat3[ 4] [ 4], f, e 
f = o, 3, 1 
e= O, 3, 1 
mat1 [ f] [ e ] = random( 1 O ) 
mat2[ f] [ e ] = random( 1 O ) 
mat3[ f] [ e ] = mat1 [ f] [ e ] + mat2[ f] [e] 
f = O, 3, 1 
e= O, 3, 1 
mat1 [ f] [e] 
e= O, 3, 1 
mat2[ f] [e) 
e= O, 3, 1 
mat3[ f l[ e] 
salto de línea 
fin 
180 
Inga. Jenny M. Rodíguez . 
Algoritmos y Programación 
Codificación en C++: 
// matsumaaleatorios: suma de matrices aleatorios ... 
#include <iostream.h> 
#include <conio.h> 
#include <stdlib.h> 
void main( ) 
{ 
int mat1 [ 4 ] [ 4 ], mat2[ 4 ] [ 4 ], mat3[ 4 ] [ 4 ], f, c; 
randomize( ); 
for( f = O; f < 4; f++ ) // llenando matrices 
for( c = O; c < 4; c++ ) 
{ 
mat1 [ f J [ c] = random(10}; 
mat2[ f] [ c ] = random( 1 O); 
mat3[ f] [e] = mat1 [ f] [e] + mat2[ f] [c ]; 
} 
or( f = O; f < 4; f++ ) // desplegar matrices 
{ 
} 
for( c = O; c < 4; c++ ) 
cout << mat1 [ f] [ c] « " "; // matriz1 
cout << "\t\t"; 
for( c = O; e < 4; c++) 
cout << mat2[ f] ( c] << " "; // matriz2 
cout « ''\t\t"; 
for( e = O; e < 4; e++ ) 
cout << mat3[ f J [e]«" "; // matriz3 
cout << endl; 
getch( ); 
} 
181 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Pogramación 
Resultado en pantalla: 
3 5 5 9 O 6 O 8 
9 4 2 2 7 6 1 6 
O 7 8 5 8 8 7 7 
3 1 4 2 O 6 9 6 
3 11 5 17 
16 10 3 8 
8 15 15 12 
3 7 13 8 
182 
Tabla simulando la corrida del anterior programa, primer par de ciclos 
llenando matrices mat1 y mat2 con aleatorios entre O y 9, mat3 es la suma 
de mat1 + mat2: 
corida f e 
1 o o 
1 
2 
3 
1 o 
1 
2 
3 
2 o 
1 
2 
3 
3 o 
1 
2 
3 
mat1[ f1 í e 1 
mat1í O 1 f O 1 = 3 
mat1 f O l f 1 1 = 5 
mat1 [ O l [ 2 l = 5 
mat1 [ O J [ 3 1 = 9 
mat1 [ 1 ][ O l = 9 
mat1 [ 1 ] [ 1 ] = 4 
matH 1 f 21 = 2 
mat1 f 1 ] [ 3 ] = 2 
mat1 f 2 lí O l = O 
mat1 [ 2 ] [ 1 ] = 7 
mat1 [ 2 ] [ 2 ] = 8 
mat1 [ 2 ] [ 3 ] = 5 
mat1 f 3 l f O ] = 3 
mat1 [ 3 ][ 1 ] = 1 
mat1 f 3 l f 2 l = 4 
mat1 f 3 l f 3 l = 2 
mat2í f [ e 1 mat3í f líe l 
mat2f O 1 í O 1 = O mat3f O 01= 3 
mat2f O 1 f 1 1 = 6 mat3f O 1 l = 11 
mat2[ O 1 f 21 = O mat3f O 21= 5 
mat2[ O l [ 3 1 = 8 mat3f O 3]=17 
mat2[ 1 ] f O ] = 7 mat3f O 1 ] = 16 
mat2[ 1 ] [ 1 J = 6 mat3[ 1 1] = 10
mat2f 1 l [ 2 ] = 1 mat3[ 1 21= 3 
mat2í 1 } [ 3 ] = 6 mat3f 1 31= 8 
mat2f 2 l f O J = 8 mat3f 2 01= 8 
mat2[ 2 1 [ 1 l = 8 mat3f 2 1] = 15
mat2f 2 ] [ 2 ] = 7 mat3f 2 2] = 15
mat2[ 2 ] [ 3 l = 7 mat3f 2 3) = 12
mat2f 3 l [ O ] = O mat3[ 3 01= 3 
mat2f 3 ] [ 1 ] = 6 mat3[ 3 11= 7 
mat2f 3 l f 2 1 = 9 mat3[ 3 21 = 13 
mat2f 3 l f 3 l = 6 mat3f 3 · 3 1 = 8 
El esultado en memoria serán datos aleatorios entre O y 9 en cada casilla de las 
2 1 d matices mat1 y mat , mat3 es a suma 
mat col col col col mat col col 
1 o 1 2 3 2 o 1 
fila O 3 5 5 9 o 6 
fila 1 9 4 2 2 7 6 
fila 2 o 7 8 5 8 .8 
fila 3 3 1 4 2 o 6 
e mat1 + mat2: 
col col mat col col col col 
2 3 3 o 1 2 3 
o 8 3 11 5 17 
1 6 16 10 3 8 
7 7 8 15 15 12 
9 6 3 7 13 8 
Inga. Jenny . Rodríguez V. 
Algoritmos y Prgramación 183 
Otro ejemplo: 
Aunque no es con matrices paralelas, elaboremos un programa que declare 2 
matrices: mat de 2 filas por 3 columnas, y tra de 3 filas por 2 columnas, enteras, 
pediremos al usuario los datos de mat y generaremos tra como la transpuesta de 
mat (filas de mat pasan a columnas de tra; columnas de mat pasan a filas de tra). 
Pseudocódigo: 
inicio 
fin 
entero: mat[ 2 ] [ 3 ], tra[ 3 ] [ 2 ], f, c 
para f desde O hasta 1 paso 1 hacer 
para c desde O hasta 2 paso 1 hacer 
escribir "Ingrese valor:", f, e 
leer mat[ f] [ c] 
tra[ c ] [ f] = mat[ f] [ e ] 
fin_para 
fin_para 
para f desde O hasta 1 paso 1 hacer 
para c desde O hasta 2 paso 1 hacer 
escribir mat[ f J [c] 
fin_para 
fin_para 
para f desde O hasta 2 paso 1 hacer 
para e desde O hasta 1 paso 1 hacer 
escribir tra[ f 1 [ e ] 
fin_para 
fin_para 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Programación 184 
Diagrama de Flujo: 
entero: mat[ 2 ] [ 3 ], tra[ 3 J [ 2 ], f, e 
f = O, 1, 1 
e = O, 2, 1 
mat [ f ][ e 1 
tra[ e ] [ f J = mat[ f J [ e J 
f = O, 1, 1 
e= O, 2, 1 
mat[ f}[ e J 
f = O, 2, 1 
c = 0,1,1 
tra[ f He 1 
Inga. Jenny M. R<�dríguez V. 
Algoritmos y Programación 
Codificación en C++: 
// matra.cpp: matriz y transpuesta, pide datos al usuario ... 
#include <iostream.h> 
#include <conio.h> 
void main() 
{ 
int mat[ 2] [ 3 ], tra[ 3 J [ 2 ], f, e; 
far( f = O; f < 2; f++ ) // filas 
far( e = O; e < 3; e++ ) // columnas 
{ 
} 
cout << "ingrese valor" << f << "," << e << A: "; 
cin » mat[ f] [e]; // pidiendo datos al usuario 
tra[ e] [ f] = mat[ f] [e]; // llenando transpuesta 
cout << "\nDatos de Matriz:" << endl; 
far( f = O; f < 2; f++ ) // imprimiendo mat 
{ 
} 
ar( e = O; e < 3; e++ ) 
cout « mat[ f] [ e J « "\t"; / mat 
cout << endl; 
cout << "\nDatos de Transpuesta:" << endl; 
ar( f = O; f < 3; f++ ) // imprimiendo tra 
{ 
} 
far( e = O; e < 2; e++ ) 
cout « tra[ f J [e] « ''\t"; / transpuesta 
cout << endl; 
getch( ); 
} 
185 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Programación 
Resultado en antalla: 
Ingrese valor O O: 100 
Ingrese valor O 1: 200 
Ingrese valor O 2: 300 
Ingrese valor 1 O: 400 
Ingrese valor 1 1: 500 
Ingrese valor 1 2: 600 
Datos de Matriz: 
100 200 300 
400 500 600 
Datos de Transpuesta: 
100 400 
200 500 
300 600 
186 
Tabla simulando la corrida del anterior programa, primer par de ciclos 
llenando matriz mat con datos ingresados por el usuario y tra con datos 
trans uestos: 
corrida f e pantalla usuario mat f] e tra [ e f 
1 o o In rese valor 0,0: 100 mat O o = 100 tra O o = 100 
1 In rese valor O, 1: 200 mat O 1 = 200 tra 1 O]= 200 
2 In rese valor 0,2: 300 mat O 2 = 300 tra 2 o = 300 
1 o In rese valor 1,0: 400 1 o =400 tra o 1 = 400 
1 In rese valor 1, 1 : 500 1 1 = 500 tra 1 ( 1 ] = 500 
2 In rese valor 1,2: 600 1 2 =600 tra 2) ( 1] = 600 
El resultado en memoria de los datos ingresados por el usuario en cada casilla de 
la matriz mat: 
mat columna O columna 1 columna 2 
la O 100 200 300 
ila 1 400 500 600 
El resu tado en memoria e os . d I d atos asigna d t . t os a ma nz ra 
tra columna O columna 1 
fila O 100 400 
fila 1 200 500 
fila 2 300 600 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Programación 187 
Ejercicios: 
Elaborar pseudocódigo, diagrama de flujo y codificación en c++ de un programa 
que: 
1. Declare 3 matrices enteras de 7 filas por 7 columnas. Pedir al usuario los
datos de mat1 y mat2 y genear mat3 como la dierencia de los datos de
mat1 - mat2. Desplegar las 3 matrices.
2. Declare 2 matrices reales, de 3 filas por 5 columnas (mat1 y mat2), en mat1
se registrarán ( pedir al usuario ), las ventas de cada vendedor ( 3 filas, una 
por vendedor ) para cada semana ( 5 columnas, una por semana ), y en 
mat2 se generaá el 20% de las comisiones que correspondan a cada dato 
que el usuario haya ingresado en mat1. Se requiere imprimir ambas
matrices.
Inga. Jenny M. Rodríguez V. 
Algoritmos y Programación 188 
6.5. ARREGLOS DE MAS DE DOS DIMENSIONES (MULTIDIMENSIONALES): 
Se pueden manejar arreglos de cualquier número de dimensiones. :o� e}e:p!o 3 
dimensiones como un cubo que tiene filas ( alto ), columnas ( ancho ), y planos o 
rangos ( profundidad ). 
También arreglos tetradimensionales ( 4 dimensiones ), pentadimensionales ( 5 
dimensiones), 6, 7, ... , n dimensiones, aunque en la vida real rara vez utilzamos 
mas de 3 dimensiones. 
Para declarar un arreglo multidimensional, se enlista el tamaño máximo de todas 
las dimensiones del arreglo: 
Así, si queremos declarar un arreglo tridimensional: 
tipo nombre areglo [ número planos J [ número _las J [número_ columnas]; 
Ejemplo: 
real temp [ 5 ] [ 25 ] [ 366 ] ( En c++: float temp[ 5 ] [ 25 ] [ 366 ] ; ) 
para guardar las temperaturas de cada día en cada uno de los 23 departamentos 
por 5 años. Este arreglo tendrá capacidad para 5 * 23 * 366 = 42,090 datos ( 
casillas ). 
Otro ejemplo: 
carácter libro [ 250 ] [ 25 ] [ 80 ] ( En c++: char libro [ 250 ] [ 25 ] [ 80 ] ; ) 
El arreglo libro nos permite almacenar todas las letras (80 caracteres, columnas ), 
para cada línea ( 25 filas ), para cada una de las páginas de un libro de 250 
páginas.Tiene capacidad para almacenar 250 * 25 * 80 = 500,000 datos(casillas). 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Programación 189 
Asignar valores: 
Ejemplo: 
tenp [ 1 ] [ 2) [ 3 ] = 26.5; // temperatura el día 3 en departamento 2 del año 1 
escribir 'Ingrese valor O, 1, 2' // pidiendo datos al usuario 
leer temp [ O J [ 1 ] [ 2 J; 
Extraer o Accesar Valores: 
Ejemplo: 
temperatura= temp [ 1 ] [ 1 ] [ 1 ]; // asignando el dato a otra variable 
escribir temp [ 2 ] [ 2 ] [ 2 ]; // desplegando el dato 
MEDIANTE CICLOS ANIDADOS 
La manera más fácil de acceder a la información del arreglo es mediante ciclos 
anidados utilizando el ciclo más externo como el ciclo de los planos, el ciclo 
medio como el ciclo de las filas y el ciclo más interno como el ciclo de las 
columnas. 
far ( int lndicePlano = O ; lndicePlano < NumPlanos; ++ lndicePlano ) 
for ( int lndiceFila = O ; lndiceFila < NumFilas ; ++lndiceFila ) 
far ( int lndiceCol = O ; lndiceCol < NumCol ; ++ lndiceCol ) 
< Procesar elemento [ lndicePlano] [ lndiceFila] [lndiceCol J ; > 
Inga. Jenny M. Rodrfguez V.
Algoritmos y Programación 
6.6. MANEJO DE ARREGLOS UTILIZANDO FUNCIONES: 
190 
Uno de los primeros ejemplos que observamos acerca de arreglos es un 
programa en el que, dentro de un ciclo, se le piden datos al usuario, se van 
guardando los datos en un arreglo, y en otro ciclo se despliegan dichos datos. 
Ahora veremos un ejemplo parecido, pero utilizaremos una función para pedir los 
datos e irlos guardando en el arreglo y otra función para desplegarlos; ambas 
serán llamadas desde el programa principal. 
Utilizaremos como parámetros el arreglo y el número de datos que el usuario 
ingrese. 
En c++, cuando pasamos un arreglo entre los parámetros, siempre es pasado por 
referencia ( aunque no pongamos el & ), ya que consumiría mucha memoria si el 
compilador creara copias de arreglos para cada subprograma. 
Se declara la constante global LONG=100 indicando que el arreglo tiene 
capacidad para guardar 100 elementos. 
Si se requieren mas o menos elementos, modificar el valor de dicha constante, 
por ejemplo así: const int LONG= 50; 
O así: const int LONG= 2000; 
Veamos el programa: 
Inga. Jenny M. Rodríguez V.
Algoritmos y Programación 
Codificación en e++: 
#include <iostream.h> 
#include <conio.h> 
191 
const int LONG = 100;/maximo numero de casillas del arreglo, se puede cambiar 
void ingresar( double a[], int& n) // subprograma de ingreso de datos 
{ 
} 
n = O; 
cout << "Introduzca datos. Para terminar pulsar -1: \n"; 
for {n = O; n < LONG; n++ ) 
{ 
cout << "elemento " << n << ": "; 
cin >> a[ n ]; 
if ( a[ n J == -1 ) break; 
} // far 
void imprimir( double a[ ], const int n, double& prom ) // subprograma que lista 
{ 
} 
double suma=O; 
far( int i = O; i < n; i++ ) 
{ 
} 
cout << ''\t" << i << " : " << a[ i ] << endl; 
suma + = a[ i ]; 
cout << "La suma en procedimiento es: " << suma << endl; 
prom=suma/n; 
cout << "El promedio en procedimiento es: " << prom << endl; 
void main() 
{ 
} 
double a[ LONG ], prom = O; 
int n; 
ingresar( a, n ); // a=arreglo, n=numero de elementos ingresados p/usuario 
cout << "\nEI areglo tiene " << n << " elementos, que son:\n"; 
imprimir( a, n, prom ); 
cout << "El promedio en main es: " << prom << endl; 
getch( ); 
Inga. Jenny . Roguez . 
Algoritmos v Programación 192 
Resultado en panta)la, suponiendo que el usuario teclea los datos 1 O 20 30:
Introduzca datos. Para terminar pulsar -1: 
elemento O: 1 O 
elementou1: 20 
elemento 2: 30
elemento 3: -1 
El arreglo tiene 3 elementos, que son: 
O: 10 
1 : 20 
2: 30 
La suma en procedimiento es: 60 
El promedio en procedimiento es: 20 
El promedio en main es: 20 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Programación 193 
En el siguiente ejemplo, vemos un programa que declara una matriz en el 
programa principal, llama a un procedimiento para que llene dicha matriz con 
números aleatorios y llama a otro procedimiento para que despliegue los datos 
de la matriz. Se pueden modificar fácilmente las dimensiones de la matriz 
modificando los valores de las constantes globales FILAS y COL. 
Codificación en c++: 
#include <iostream.h> 
#include <conio.h> 
#include <stdlib.h> 
const int FILAS = 5; 11 puede modificar este valor para mas o menos filas 
const int COL = 5; !! puede modificar este valor para mas o menos columnas 
void llenar( int mat[ FILAS ] [ COL ] ) // llenar matriz con aleatorios 
{ 
randomize( ); 
ar( int f = O; f < FILAS; f++) 
for( int e = O; c < COL; c++ ) 
mat[ f] [ e ] = random( 100 ); // aleatorios entre O y 99 
} 
void desplegar( int mat[ FILAS J [COL]) // desplegando matriz 
{ 
far( int f = O; f < FILAS; f++ ) 
{ 
} 
} 
for( int e = O; e < COL; c++ ) 
cout « mat[ f J [ e J « "\t"; 
cout << endl; 
void main() 
{ 
int mat[ FILAS] [ COL J;
llenar( mat ); // llamando procedimiento que llena matriz 
desplegar( mat ); // llamando procedimiento que despliega matriz 
getch( ); 
} 
Inga. Jenny M. Roguez V.
Algoritmos y Programación 194 
Resultado en pantalla. El usuario no introduce ninqún dato: 
72 
5 
26 
21 
94 
16 
69 
75 
49 
58 
75 
44 
80 
48 
31 
43 
55 
93 
99 
21 
68 
4 
78 
69 
94 
Inga. Jenny M. Rodríguez .
Algoritmos y Programación 195 
6.7. CADENAS DE CARACTERES 
C++ no tiene datos predeinidos tipo cadena (string); en su lugar, c++ manipula 
cadenas mediante arreglos de caracteres que terminan con el carácter nulo 
ASCII: \O 
Se accede a una cadena mediante un apuntador al primer carácter de la cadena. 
El valor de una cadena es la dirección (constante) de su primer carácter. Por lo 
tanto, una cadena es un apuntador constante; de hecho, un apuntador al primer 
carácter de la cadena, igual que en los otros arreglos. 
Declaración de un arreglo de caracteres: 
char color [ 1 O ] ; // declara un arreglo llamado color con 1 O casillas 
color 
o 1 2 3 4 5 6 7 8 
Declarando e inicializando un arreglo de caracteres: 
9 
char color [ 1 O] = { 'a' , 'z' , 'u' , 'I' } ; // declarando e inicializando ar. de caracteres 
color 
1 a I z O 1 1 u 11 2 3 4 5 6 
Declarando e inicializando una cadena de caracteres: 
7 8 9 
char color [] = "azul"; // cadena entre comillas, al final asigna carácter nulo: \O 
color 
1 a I z O 1 2 3 4 5 6 
Otra manera: escribiendo separadamente cada letra: 
7 8 
char color [] = 'a', 'z' , 'u' , 'I' , '\O' ; // cada carácter entre apóstrofos 
color 
1 a I z O 1 1 u 11 1 \O 2 3 4 5 6 7 8 
9 
9 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Programación 
Teclee el siguiente programa y observe los resultados: 
#include < iostream> 
#include < conio> 
void main() 
{ 
char texto[ 80 ]; // declarando 
char orden[ 40 ]; // declarando 
char color[] = "azul"; // declarando e inicializando, al final asigna \O 
cout << color<< endl; // despliega azul sin las comillas 
196 
cout << "Tamano del arreglo:"<< sizeof (color)<< endl; // despliega 5 
cout << "O: " << color[ O] << endl; // despliega a 
cout << "1: " << color[ 1 ] « endl; // despliega z 
cout << "2: " << color[ 2] << endl; JI despliega u 
cout << "3: " << color[ 3] « endl; // despliega 1 
cout << "4: " << color[ 4] << endl; // despliega vacio 
cout << "5: " << color[ 5] << endl; // despliega vacío 
char num[ ]={ 'u' , 'n' , 'o' , '\O'}; // declarando e inicializando 
cout << num << endl; // despliega uno 
cout << "Tamano del arreglo: " << sizeof( num ) << endl; // despliega 4 
cout << "O: " << num[ O] << endl; // despliega u 
cout << "1: " << num[ 1 ] << endl; // despliega n 
cout << "2: " << num[ 2] « endl; // despliega o 
cout << "3: " << num[ 3] << endl; // despliega vacio 
const char *ptrnombre = "Pepe"; 
cout << "Tamano de ptrnombre: "<< sizeof( ptmombre) << endl; 
cout << "ptmombre: " << ptmombre << endl; // despliega Pepe 
cout << "&ptrnombre: "<< &ptrnombre << endl; // despliega direccion de P 
cout << "*ptmombre: " << *ptrnombre << endl; // despliega indireccion: P 
cout << "O:"« ptmombre[ O]<< endl; // despliega P 
cout << "1: " << ptrnombre[ 1 ] << endl; // despliega e 
Inga. Jenny M. Rodríguez V.
Algoritmos y Programación 
cout « "2: " « ptrnombre[ 2 ] << endl; // despliega p 
cout « "3: " « ptrnombre[ 3] << endl; // despliega e 
cout << "4: "<< ptmombre[ 4] << endl; // despliega vacio 
getch{ ); 
197 
Inga. Jenny M. Roguez .
Algoritmos v Programación 198 
Cuando le pedimos al usuario que ingrese los datos a guardar dentro de una 
cadena, si utilizamos la instrucción cin >> para leer y guardar en la cadena, 
perderemos los datos que estén después de un espacio ingresado por el usuario. 
Por ejemplo: si le pedimos al usuario que ingrese un nombre y éste teclea Isaac 
Newton, en la cadena sólo se guardará Isaac, se perderá lo que esté después de 
un espacio. 
Para evitar esto se utiliza la función: 
gets( nombre_cadena ); que pertenece a librería stdio 
o la función:cin.getline ( nombre_cadena , largo_cadena ); que pertenece a librería iostream 
como veremos en el siguiente ejemplo: 
// cadlectura.cpp leyendo cadenas de caracteres ... 
#include <iostream.h> 
#include <conio.h> 
#include <stdio.h> // contiene gets( ) 
void main() 
{ 
char nombre[ 30 ]; 
cout << "ingrese nombre:"; 
cin >> nombre; // el usuario ingresa Isaac Newton 
cout << nombre << endl; // despliega Isaac, espacio = fin de cadena 
cout << "ingrese nombre: "; 
gets( nombre ); // el usuario ingresa Isaac Newton 
cout << nombre << endl; // despliega Isaac Newton 
getch( ); 
} 
// en lugar de gets( nombrecadena ) se puede utilizar cin.getline 
// cin.getline( nombrecadena, largocadena ) ; 
Inga. Jenny M. Rodríguez V.
Algoritmos y Programación 199 
La librería string.h contiene muchas funciones para manipular cadenas de 
caracteres, veamos algunas: 
#include <iostream.h> 
#include <conio.h> 
#include <string.h> 
void main() 
{ 
char cadena[100J="lsaac Newton"; // declarando e inicializando 
cout << "cadena: " << cadena << endl; // despliega Isaac Newton 
// strlen: largo de una cadena 
cout << "largo de cadena:"<< strlen(cadena) << endl; // despliega 12 
// strcpy: asignar a una cadena 
// cadena="George Washigton"; // no se le puede ambiar valor es un 
puntero constante 
strcpy(cadena,"Buenos Dias"); // inicializa y copia Buenos Dias en adena, 
cout << "Asignar Buenos Dias a cadena: " << cadena << endl; / despliega 
Buenos Dias 
// strcat: concatenar: añadir una cadena a otra 
strcat( cadena," Guatemala"); 
cout << "Concatenar Guatemala a cadena: " << cadena << endl; / despliega 
Buenos Dias Guatemala 
// strcmp: comparar cadenas; retorna un valor entero: 
// negativo si la primera es menor; O si son iguales, positivo si la pimea es 
mayor 
cout << "Comparando hola con HOLA: " << strcmp("hola�,"HOLA·) << endl; 
//despliega 32, hola es mayor que HOLA 
cout << "Comparando HOLA con HOLANDA: " « strcmp(ªHOLAª,"HOLANDN) 
« endl; // despliega -79, HOLA es menor 
Inga. Jenny M. Rodríguez . 
Algoritmos y Programación 200 
// strrev: invierte los caracteres de una cadena 
cout << "Invirtiendo hola: "<< strrev("hola") << endl; // despliega aloh 
// strupr: convierte a mayusculas; strlwr: convierte a minusculas 
cout << "Convirtiendo Hola a mayusculas: " << strupr("Hola") « endl; // 
despliega HOLA 
cout << "Convirtiendo Hola a minusculas: " << strlwr{"Hola") « endl; // 
desoliega hola 
// strcspn: busca un caracter dentro de una cadena, 
// retorna el numero de posicíon en donde encontro, 
// si no existe, retorna el numero del caracter nulo \O 
cout << "Buscar o dentro de Hola: " << strcspn("Hola","o") << endl; // 
despliega 1, posicion de la o 
cout << "Buscar x dentro de Hola: " << strcspn("Hola","x") << endl; // 
despliega 4, fuera de posicion 
char *resultado; 
resultado=strstr("Adios mundo","mu"); // buscando mu dentro de Adios 
mundo 
cout << "Resultado de buscar mu dentro de Adios mundo: " << resultado <<
endl; 
resultado=strstr("Adios mundo","ma"); // buscando mu dentro de Adios 
mundo 
cout << "Resultado de buscar ma dentro de Adios mundo: " << resultado << 
en.di; 
getch( ); 
} 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Programación 201 
La función strtok 
Permite romper una cadena en subcadenas o tokens. Un token es una 
secuencia de caracteres separados por caracteres delimitadores ( por lo general 
espacios o caracteres de puntuación ). 
#include <iostream.h> 
#include <conio.h> 
#include <string.h> 
void main( ){ 
char cadena[]= "01/10/2008"; 
char *separador = " / , " ; 
char *ptr = cadena ; 
cout << "Cadena: " << cadena << endl; 
ptr = strtok( cadena, separador ) ; / primera subcadena asignada a ptr 
cout << "dia: " << ptr << endl; 
ptr = strtok( NULL,-"f'); 
cout << "mes: " << ptr << endl; 
ptr = strtok( NULL, separador ) ; 
cout << "anio: " << ptr << endl << endl; 
1 otro ejemplo: utilizando ciclos si hay muchos tokens 
char oracion[ ] = "Esta oracion contiene 5 tokens" 
inicializando 
char *separ = " n ; 
char *ptrToken = oacion ; 
cout << "Utilizando ciclos:" << endl; 
cout << "Oracion: " << oracion << endl; 
ptrToken = strtok( oracion, separador ) ; 
while( ptrToken) 
{ 
cout <<"token:"<< ptrToken << endl; 
ptrToken = strtok( NULL, separador) ; 
} 
getch(); 
} 
11 declarando e 
Inga. Jenny . Rodríguez V. 
Algoritmos y Programación 202 
6.8.1. ESTRUCTURAS O REGISTROS 
Conjunto de datos relacionados que se almacenan juntos en memoria y que 
pueden ser de diferente tipo (heterogéneos), a diferencia de los arreglos, cuyos 
datos deben ser del mismo tipo ( homogéneos ). 
Supongamos que necesitamos almacenar datos acerca de libros, dichos datos 
podrían ser: título del libro, autor, número de unidades en existencia, precio de 
venta. 
Definimos una estructura como la siguiente: 
Pseudocódigo: 
estructura inventario 
inicio 
carácter titulo [ 25 1 ;
carácter autor [ 30 1 ;
entero num; 
real precio_venta; 
fin 
En c++: 
struct inventario 
} ; 
char titulo[ 25 J;
char autor[ 30 J;
int num; 
float precio_venta; 
Y así creamos un tipo de dato llamado inventario que contiene los miembros o 
campos arriba descritos; en memoria podría verse así: 
carácter titulo 2 carácter autor 30 entero num real recio venta 
Auique la mayoría de los autores no utilizan la definición de una estructura 
dentro del pseudocódigo ni dentro del diagrama de flujo, pensamos que podría 
11 't ' d .. d t t . ser, en genera , a sm axis e creac1on e una es ruc ura as,: 
pseudocódigo diagrama de lujo codiicación c+ 
esructura nombreesuctura esructura nombreesuctua sruct nombreestructura 
inicio niio { 
tipo campo tipo campo tipo campo ... ... .. . 
in in }; 
Inga. Jenny M. Rodríguez V. 
Algoritmos y Programación 203 
Ejercicios: 
Definir al menos 5 campos o miembros para las estructuras siguientes: 
• _Empleados
• Alumnos
• Clientes
Inga. Jenny M. Rodríguez V.
Algoritmos y Programación 
Declaración de tipos estructura: 
204 
Ya creamos el tipo de dato estructura, ahora dentro del programa se declara 
utilizando el nombre de tipo y el nombre o nombres de datos así: 
nombreestructura nombreda toestructura 
Ejemplos: 
inventario libro; 
inventario libro, ítem; 
de la misma manera que declararíamos las variables: 
entero cont; 
entero cent, i; 
Acceso individual a los miembros o campos de una estructura: 
Dentro del programa se maneja cada uno de estos miembros o campos utilizando 
el nombre definido de la estructura, el operador punto y el nombre del miembro o 
campo así: 
libro.titulo 
libro.num 
carácter titulo 25 carácter autor 30 entero num real recio venta 
libro.título libro.autor libro.num libo.precio_venta 
En genera. la sintaxis del manejo de un campo dentro del programa es: 
nombredatoestructura.nombrecampo 
Inga. Jenny M. Roríguez V. 
) 
Algoitmos y Programación 205 
Asignando valores a los miembros de una estructura: 
Ejemplo: 
libro.num = 25 // poner un 25 en el campo num de la estructura libro 
Ejemplo: 
escribir "Ingrese precio: " 
leer libro.precio_venta // poner en campo el valor que el usuario ingrese 
Accesando a los miebros de una estructura: 
Ejemplo: 
existencia = libro.num // pasar al campo existencia el valor que hay en 
libro.num 
-Ejemplo: 
escribir "el precio es:", libro.precio_venta // desplegar el contenido del campo 
EJERCICIOS: Trabajando con el dato libro: 
• Pedir al usuario el título de un libro y guardarlo en el campo respectivo.
• Pedir al usuario el autor de dicho libro y guardarlo en el campo respectivo.
• Asignar 100 al campo num.
• Asignar 250 al campo precio_venta.
• Calcular venta_ Total como el producto de num * precio_venta.
• Desplegar los valores de todos los campos incluyendo venta_ Total.
Inga. Jenny M. Rodríguez V.
Algoritmos y Programación 206 
Ejemplo: 
En el siguiente programa, veremos el manejo de una estructura, que consiste en 
deinirla o crearla, declararla, asignarle datos y accesar a sus datos. 
Pseudocódigo: Diagrama de Flujo: 
estructura