Libro Algoritmos PDF

PRIMERA EDICIÓN, Enero de 2009
SEGUNDA EDICIÓN, Enero de 2010

corregida y aumentada.
ALGORITMOS Y PROGRAMACIÓN
Inga. Jenny M. Rodríguez V.
DERECHOS DE AUTOR REGISTRADOS ®

Se prohibe su reproducción total o parcial
por cualquier medio.
G... .;a,w..A, C. A., 2010.

AGRADECIMIENTOS
A Dios, por todas las bendiciones recibidas y por recibir.
A mis padres y hermanos, 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áctico y sen�llo

que ayude en los primeros pasos del aprendizaje de los algoritmos y la
programación.
o deseo llenar dicho texto con demasiada teoría, mas bien con mucha
oráctica aunque incluyo bastantes explicaciones.
E.n este libro nos enfocaremos a la programación orientada a procedimientos

y al lenguaje de programación C++, ya que dicho lenguaje es ideal para
aplicaciones científicas y nos permite entrar al ámbito tanto de la
programación orientada a procedimientos como de la programación
orientada a objetos.
Con las bases de este libro, más adelante usted podrá profundizar en otros
enguajes.
Deseo recalcarle que /a programación es una habilidad que adquirirá con

mucha práctica.
Espero que usted, que está iniciando en esta rama del saber, aprenda desde
el principio que así como hay nom,as de calidad para producir calzado,
medicinas, y otros productos, también hay normas de calidad para producir
programas, y desde ya usted aprenda a elaborar programas con calidad, con
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 Instrucciones .....................................................................5
1.8. Datos, tipos de datos.......................................................................5
1.9. Memoria e identificadores ................................................................6
1.1O. La operación asignación................................................................8
1.11. Funciones internas.........................................................................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. Estructura típica 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.1O. 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. Alternativa 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 flag ).....................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 internos...............................................................133
5.3. Funciones definidas 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 )..........................1SO
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 arreglos utilizando funciones......................................190
6. 7. Cadenas de caracteres................................................................195
6.8. Estructuras o registros.................................................................202
6.8.1 Estructuras........................................................................202
6.8.2. Estructuras anidadas.......................................................209
6.8.3. Arreglos de estructuras....................................................214
6.8.4. Arreglos de estructoras utilizando procedimientos..........219
"'- 9. ;.
•..-cnivos....................._. .................................................................221
5.9. 1. '\rchivos texto ..................................................................221
6.92.. .:i.rchivos binarios .............................................................225
.! :.,orit,nos y Programación 1
1. DEFINICIONES GENERALES
-ciaremos nuestro estudio con algunas definiciones generales:
.1. LAS PARTES DE UN SISTEMA DE COMPUTO

3.as·camente son cuatro:
• hardware,
• software,
• datos y
• usuarios.
liARDWARE:
::O junto de componentes físicos de una computadora. Equipo físico.
=-.e-nplos: monitor, impresora, disco duro, etc.
SOFTWARE:
==-
:C. ·unto de programas que controlan el funcionamiento de una computadora.
po lógico.
=:-enplos: dos, Windows, Word, etc.
DATOS
-ecnos 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
3iel'
:.eq eñas piezas de datos de distintas maneras convirtiéndolas en información
=>orlo tanto, INFORMACION implica datos procesados y organizados.
USUARIO
=s la persona que opera la computadora. Ninguna computadora es
::::ompletamente autónoma. Las personas diseñan, construyen, programan y
:oaran todos los sistemas de cómputo.
Inga. Jenny M. Rodrfguez V.

Algoritmos y Programació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 interruptor,
• 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 café
• Preparar un pastel

-.Jgoritmos 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 modifica 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.

.l,Jgoritmosy Programación 5
TRADUCTORES DE LENGUAJE
So orogramas que traducen instrucciones de programas fuente de alto nivel a
e;,guaje 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
• Aritmético/ lógicas
• Selectivas
• Repetitivas
• De principio/ fin
.8. DATOS, TIPOS DE DATOS

5e 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)

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

! !
• Estructurados ( 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 reservamos 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

'orna de acuerdo a las siguientes normas:
we. carácter que forma un identificador debe ser una letra (a, b, e, ...
3. -
2. _::s ::a ..;s '.:2racieres pueden ser letras(a, b, ... ), o dígitos(1,2,... ) o guión
-':;-·
3. � ::a-_ -::e::=-- ce':>e ser representativo del uso que se le dará

(--=.-.ó-:::::

-.goritmos y Programación 7
�::;r ejemplo si declaramos la variable edad, reservamos 4 bytes en los que

�rdaremos valores numéricos enteros, como: 28 ó 36 ó 59, etc.
5 declaramos la variable nombre, reservamos unos 30 bytes para guardar

:::adenas de caracteres como: Juan Pueblo.
= declaramos la variable sueldo, reservamos 4 bytes para guardar valores

-=a es como 3824.56.
s· éeclaramos la variable x, no tendremos idea de lo que guardaremos en dicho

::s:::iacio de memoria, por lo que evitaremos utilizar identificadores tan cortos y
::a,..... :::,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 RAM
-:;nbre

Algoritmos yProgramacióñ B
1.1 O. LA OPERACION ASIGNACION
Después de haber declarado o definido o reservado 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 ó edad� 23 (si es numérica)
• nombre= 'Juan Pueblo' ó nombre� 'Juan pueblo' 'f-(si es
- /carácter)
• sueldo = 3824.56 ó sueldo� 3824.56
• bandera = falso ó bandera= 5 < 3 (si es lógica).
Al asignar valor a dichas variables, en memoria se podría representar así:
Memoria RAM
edad
[fü
nombre
IJ Iu la In I IP lu le lb 11 lo 1
sueldo
113824.56 I
1.11. FUNCIONES INTERNAS

Los lenguajes contienen funciones matemáticas como:
• abs(x); calcula el valor absoluto de x
• s·..,, x); calcula el seno de x ( en radianes )
• cos{x¡; ec'.cuJa el coseno de x ( en radianes )
• :an[x ,; C21CL:la la �angente de x ( en radianes )
• r�x:· ��o natural de x ( x>O)
• log\x,1; og¿-::.io :>ase 10 de x ( x>O)
• exo(x ,; ex:,c...e.--..:::ic' natural de x ( ex )
• sqr{x); ca!a..'2 a :::uacrado de x ( square ( x2 ))
• sqrt(x); se ..:a.-s � -aiz cuadrada de x ( x>=O))
• y muchas ocras -=--

4Jqorffmos y Programación 9
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)
t.. x = tan(0) + cos(0)
5. x =- abs(5) - exp(0)
1• 2. JERARQUIA DE LAS OPERACIONES MATEMÁTICAS

_::s lenguajes se rigen por las mismas reglas prioritarias que la matemática, estas
s.:::n:
• 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.

Algoritmos y Proqramacióa JO
Ejemplo:
_1_ �parte entera del cociente ( div)
Al dividir 5 entre 3: 315
2 "?residuo antes del punto decimal ( mod )

Por lo tanto:
x = 5 div 3; x vale 1
x = 5 mod 3; x vale 2 (residuo).
x = 5/3; x vale 1.6667 ( incluye los decimales).
Otro ejemplo:
_3_ "?parte entera del cociente ( div)
Al dividir 7 entre 2: 217
1 "?residuo antes del punto decimal ( mod )
Por lo tanto:
x = 7 div 2; x vale 3
y = 7 mod 2; y vale 1
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 mod 6
=
• X = 50/6
• x = 200érv 3
• X = 200 rnod 3

�y Programación . 11
plos de jerarquía de operaciones:

• X=3+6*14
x=3+48 (primero se multiplica, por último se suma)
X=87
• x = -4*7+2"3/4-5 (primero el exponente)

x=-4*7+ 8 /4-5 (después multiplicaciones y divisiones)
X = -28 + 2 -5 (por último sumas y restas)
X= -31
• x = 3+2* (18-4"2 ) ( -primen:> el exponente dentro del signo de

agrupación )
x = 3+2*(18-16) . ( signos de agrupación )
x=3+2*2 ( multiplicación )
x = 3+4 ( por último sumas y restas )
x=7
• ¡ = 2°+ 52 / 5 - 7* 8 ( primero los exponentes )

'J =1 +25/5 - 7 * 8 ( multiplicaciones y divisiones )
=1 + 5 - 56 ( por último sumas y restas )
! = -50
• :: = 7+3 ** 5 -(4*7+40 div 8 -36mod 5 )+16/ 8+ 5

z = 7+ 42 3 - ( 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+ 24
.
y= 34.
=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

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�-- algorítmica: x = 1 / y

y
• expresión aritmética: a = -1L( 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 + .!]
• -esl=·- :o-.sjca:
ex=_ X = O
Q - r --Js
q
algorítmica: y = S.-:--E .. - _,.,, o)/ ( p/ q - r" sqrt(s))

.l,qqitmos y Programación 13
§ercicios: exprese en forma algorítmica las siguientes expresiones

aitméticas
• a= 5 ( z + w)
• d= m+n
p - q
• x=_m__+ p
n
• b= x + v
u+ .Y.
a
• x=m + _n_
p-q
2
• a = r ...J ( r2 + h )

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.
\y Operadores relacionales:
Permiten comparar dos operandos. El resultado es verdadero o falso, estos
operadores son:
Operador Relacional Significado

< 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 )
'a.so

.&q;r:mosy Programación 15
§e!cicios: encuentre el valor de las siguientes expresiones lógicas:
· x=2 y=3
,e • 5 + y ... 3 / 4 ) < = ( x ... 3 div y ) respuesta: falso
500 mod 3 * 2 ** 4 ) > ( ( 15 * 2 ) = ( 60 * 2 / 4 ) ) respuesta: falso
• • 5 mod 4 * 3 >= 15 - 2**3 espuesta: verdadero

)
�- • 5 od 4 * 3 >= 15 - 2 ** 3 respuesta: verdadero
Operadores lógicos:
:e- :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

sg_e�:e de mayor a menor:
• Signos de agrupación
• =xponentes y radicales
• • ultiplicación;división, div, mod
• =. <> , < ' > , <= ' >=
• o
• V
• o
- ::o; tinuación se presenta la tabla de verdad de los operadores lógicos:
p a -P -a PoQ p AQ
-e-rladero verdadero falso falso verdadero verdadero
,:'"':ladero falso falso verdadero verdadero falso
:also verdadero verdadero falso verdadero falso
:also falso verdadero verdadero falso falso

Algoritmos y Programación 16_
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. ( 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 div 2 • 4 ) > ( 15 / 2 * 6 >= 15 * 2 / 17 = 15 ))
Reso'"es:a: erro;, no se puede comparar un valor lógico y un numérico

utiliza-ca _1 o::>erador relacional.
..:
.lqxitmos y Programación 17
-15. LA OPERACIÓN DE DECLARAR O DEFINIR:

::.:.:-a poder utilizar la memoria RAM en un programa se declara o define, esto nos
:enme reservar los espacios de memoria que utilizaremos para guardar los
� a procesar por nuestro programa.
:eoemos definir el tipo de dato ( entero, o real, o carácter o lógico ) que

;x.;a;car�mos ya que esto también implica el número de bytes de memoria a
-I::.:zar.
-=--..:iién debemos especificar el nombre o identificador de la variale siguiendo las

-cr-,.as que vimos anteriormente.
�to general para declarar una o varias variables es:
tipo identificador ( si es una sola variable) o

tipo identificador1, identificador2, ..., identificadorN (si son varias
ariables)
�ernplos:
• entero edad
• entero horas, nota
• -eal sueldo
• carácter letra
• lógico bandera
- -- :a anterior secuencia de declaraciones reservamos memoria RAM, la cual

-so�taremos en la siguiente tabla:
horas nota sueldo letra bandera
:::,o dijimos antes, para poner datos adentro de las variables se utiliza la
:ce.-ación asignación.

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 f- 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 conserva el último valor asignado.
Ejemplo de asignación a las variable� antes declaradas:

1. edad f- 20 //almacena 20 en el espacio de memoria llamado edad.
2. edad� 15 // se pierde el valor anterior, se almacena el 15
3. edad f- edad + 1 // como había un 15, al sumarle 1 se almacena 16
4. edad f- edad -10 // como había un 16, al restarle 10 se almacena 6
5. edad f- edad * 3 / 2//como había un 6,por 3 = 18 dividido 2,almacena 9
6. horas f- 40 // se almacena 40 en variable horas
7. sueldo f- horas * 15 // se almacena 600 en sueldo
8. nota f- 80 // se almacena 80 en nota
9. letra � 'a' // se almacena letra a en variable letra
10. bandera f- 5 < 2// se almacena O= falso en variable bandera
A continuación, tabla que muestra el resultado en memoria de las anteriores

d ---·=edad
----·-··
No.Asignación 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
4g::rtmos yProgramación 19
Ejercicios: En cadau no d e los siguientes incisos,cuál es el valorfinal?
• a=5 b= 10
a= a+b
a= a/3*2 ** 3
� = aIb
• 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+ Bmod C
X = ( A+ B)mod e
Inga. Jen,:iy M. Rodrfguez V.

1.17. CICLO DE PROCESAMIENTO DE DATOS
datos
entrada •I proceso 1------�salida
leer o read escribir o write (instrucción)

teclado monitor o impresora (dispositivo)
entrada salida
Aquí tenemos al usuario de un programa (la persona que lo está utilizando o

ejecutando).
El usuario 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 mer.ioria ram en celdas a las que se les da un nombre y un
tipo.
El programa utiliza esos datos que el usuario ingresó, los procesa ( suma, resta,
compara, ordena, e�c.l oor medio del cpu de la computadora.
El programa imprime 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 cons�!e el ciclo de proceso de datos.

1! -t: c.s y Programación 21
EJEMPLOS DE ALGORITMOS
tll.,..:J60 de un algoritmo que sólo tiene salida:
�·'Hola' (salida)
T.1110 despliega la palabra Hola en el monitor (utilizar la instrucción
�o en pantalla:
tar la sangría en la instrucción escribir. Esto le da claridad al
ejemplo de un algoritmo que sólo tiene salida:
:Saibir 'Bienvenido a la programación' ( salid_a)
::s:c ::: -;;oiitmo despliega Bienvenido a la programación en el monitor.
:aco en pantalla:
--=-- - �e en pantalla no salen los apóstrofos.
_ e-;emplo de un algoritmo que sólo tiene salida:
escribir 'Hoy es un hermoso día' (salida)
s� ;:igoritmo despliega Hoy es un hermoso día en el monitor.
:..:5... :ado en pantalla:

-: eS un hermoso dia
:a: oue en pantalla no salen los apóstrofos.

Ejercicios:
• Escriba un algoritmo que despliegue su nombre en pantalla.
• 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 significa 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 ( reservar 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 (entrada)
escribir 'Usted tiene' , ed, ·�ños' -{salida)
fin
terior declara la variable entera ed, seguidamente se le despliega

al usuaio u, nensaje en pantalla Ingrese su edad, supongamos que el usuario
responde tedea;,do un 20, el número 20 se almacena en la variable ed, en la
siguien�e ·.s:.... cción, se despliega el mensaje: Usted tiene 20 años, finaliza el
programa.
Notar que ed ,o se esaf:)e entre apóstrofos en la instrucción· escribir ya que no

queremos des;).eg:.; ':? ::ia!abra ed sino el dato contenido en memoria en la
variable ed.

•e•i: us y Programación 23
ue el usuario teclea 20:
;a-os que el usuario ejecuta el programa por segunda vez.
E 39=.---:;-,o anterior declara la variable entera ed, seguidamente se le despliega

__:a.-o n mensaje en pantalla Ingrese su edad, supongamos que el usuario
_.'."n,:-e :ecieando 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
=----
:::r-�
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
,;,
años
años
�. Ingrese su edad: 41 41 Usted tiene 41
-
aéios
años
= �mos declarar una variable para cada dato que le pedimos al usuario.

,
Otro ejemplo:
Elaborar pseudocó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 (entrada)
escribir 'La temperatura es ' , temp, ' grados' (salida)
fin
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 32.5
qrados
2 Ingrese temoeratura: 35.1 35.1 La temperatura es 35.1
grados
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 terr;>e.,-a� -a: 28.7 28.7 La temperatura es 28.7
grados

3 -lJ: es r:Programación 25
&,cuae :lSeUdocódigo que pida al usuario que ingrese dos datos: dia y mes y
es cespliegue. Ambos datos son enteros, no contienen decimales.
-..e.o: di,me
� 'Ingrese dia y mes: '
=- =-
eer-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:· 1 11 1 11 El dia es 1 el mes es 11

...
Ejercicios: elabore un pseudocódigo:
• 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
posteriormentE:l desplegaremos el resultado de este cálculo.
inicio
entero: ed, grad
escribir 'Ingrese su edad:
leer ed (entrada)
grad = ed + 6 (proceso)
escribir 'Se graduará a los', grad, 'años' < (salida)
fin
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

7 •r. os y Programación 27
esentemos esta corrida simulemos otras 4 en la si uiente tabla:

-e saje resp. variable variable mensaje en pantalla
:a.talla usuario ed rad
:-e-ese edad 18 18 24 Se raduará a los 24 años
21 21 27 Se raduará a los 27 años
:sa..oocódigo se pudo haber escrito de la manera siguiente:
::e::a.-aremos la variable grad, no utilizaremos esta variable para guardar el

-=----� ,_-::> el calculo, en cambio haremos el cálculo dentro de la instrucción de
=.-:ero: ed
::S--roir 'Ingrese su edad:
:ae· ed (entrada)
::SerDir 'Se graduará a los : ed + 6, 'años' (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 -.as e -ciente.
oniendo ue el usuario teclea 18:
- esentemos esta corrida simulemos otras 4 en la si uiente tabla:

mensaje en
antalla
resp.
usuario
variable
ed
mensaje en pantalla
18 18 Se raduará a los 24 años

=-.- ?::elante, utilizaremos este método cuando sea posible.

Algoritmos y Programación 28.
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' (proceso y salida)
fin
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
,__
4 1 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 toéa la corrida del programa, no cambia, por eso se !lama constante.
En un a1go;i-ro sa pueden obviar algunos detalles como el mensaje ingrese

kilos, y solar.ene :n-e.- la instrucción leer kil.
También el me...,Sc:_e ce salida puede ser más simple como escribir kil*conver y
dejar los detalles ::>a..---a el ::irograma final.
Así lo haremos en el s�:.. e.,:e ejemplo:

S L o.. y Programación 29
base y altura de un rectángulo y
� oa, al
�:::ia.al (entrada)
ba * al, 2 * ( ba + al ) ( proceso y salida)
::oo simulación de 5 corridas:

área erímetro
1 1 1 4
3 4 12 14
10 5 50 30
7 6 42 26
15 20 300 70
1 1•-=::o.::s:
�-Rr:r;-.:- � :lSeudocódigo de un programa que:
= :::: Oólares y despliegue Quetzales, 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 (lado ) y perímetro (4 *lado ).

2
• = =-= -adio y despliegue diámetro, área y perímetro del círculo (diámetro= 2

��-::> área= TT radio2 , ptirímetro = 2 TT radio).

Algoritmos v Proqramacióa 30
�
1.19. DIAGRAMAS DE FLUJO
Se utilizan para representar un algoritmo en forma gráfica, algunos de los
símbolos son:
( inicio ) e fin ) /entrada/ proceso
salida a
pantalla
�
�
�
�
-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)
�
31
�:dol
:::::-.s�nte real cambio=8.2
:Sa""bir 'Ingrese Dolares:'
ee.-dol
es.::roir 'Quetzales = ' , dol * cambio
real: dol
constante real cambio=8.2
/ dol /
< ¡
'Quetzales = ' , dol*cambio
_=>
onie�el usuario teclea 5:
simulando 5 corridas del al oritmo:

cambio dol Mensa·e antalla .
8.2 5 Quetzales = 41
2 8.2 10 Quetzales = 82
3 8.2 75 Quetzales = 615
4 8.2 100 Quetzales = 820
5 8.2 250 Quetzales = 2050
Algoritmos y Programación J--2
Resolvamos el ejemplo de convertir pulgadas a centímetros, pseudocódigo y d.f.:
Pseudocódigo:
iniqio
real: pul
escribir 'Ingrese pulgadas: '
leer pul
escribir 'Centímetros= ' , pul*cambio
fin
Diagrama de Flujo:
( inicio )
¡
real: pul
/ pul/
< l
'Centímetros= ' , pul • cambio
J
i
G;J
Ingrese pu,gadas: 1
Centímetros = 254
Tabla con simulación de 5 corridas:

corrida cambio pul Mensaje pantalla
1 1 2.54 1 Centimetros = 2.54
2 1 2.54 2 Centímetros = 5.08
3 1 2.5-1 5 Centímetros= 12.7
4 1 2.5L
-�
10 Centímetros = 25.4
5 1. 2 -,, 50.5 Centímetros = 128.57
Inga. Jenny M. Rodriguez V.
Pr. ramación 33
•..,'!!!:"-es .m programa que pida dos números, luego calcule y despliegue la

:S:a y multiplicación de esos dos números que el usuario ingresó.
-..:1::1::::x::-�o y d.f.:
� ,n2
�:, - 'Ingrese dos números: '
es:!"�·, 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:

Algoritmos yProgramació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 flujo 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= TT radio2 , perímetro= 2 TT radio) .
• Pida base y altura de un rectángulo y calcule y despliegue área ( base *

altura ) y parímetro ( 2 base + 2 altura ).

, � ramación 35
2. PROGRAMACION EN C++
ESTRUCTURA GENERAL DE UN PROGRAMA EN C++

: r--==:-.cs de preprocesador (header files, librerías, bibliotecas)
:__,:::-a ·ones globales (variables y constantes)
2 : �don principal main( )
=.r -es definidas por el usuario
:.:J""".-=> -�rios 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
::iOCjue de sentencias, terminan con ;
_Q DE UN PROGRAMA SENCILLO EN C++
_ -o.cpp. Programa de saludo.

:,-:,= -:-:1a imprime Bienvenido a la programacion C++
:::i._--: << "Bienvenido a la programacion C++\n";
-'"=
J programa codificado en c++ que despliegue su nombre en una línea y
-e o de carnet en otra línea.

2.3. TIPOS DE DATOS EN C++

Básicamente son:
• Enteros
• Coma flotantes (reales)
• Caracteres (char)
• Lógicos (bool)
Tipo Eiemplo Tamaño (bytes) Ranqo(Min-Max)

bool o 1 O .. 1
char 'C' 1 -128..127
short int -15 2 -32768..32767
unsiqned int 325 4 0. .4 2941 967 295
int 1024 4 -2147,483 648 .. 2147,483637
unsigned long 262144 4 0..4 294,967 295
long 2000000 4 - 2147,483 648 . . 2147,483637
float 10.5 4 3.4*10"'°..3.4*1o,jlj
double .00045 8 1. 7*1o·JVO .. 1 . 7*1O""'º
""
lonqdouble 1e 10 3.4*1o-,�_,, •, 1.1*1a-•�->L
2.4. DECLARACIÓN DE VARIABLES:
TipoDato 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;

37
declarar constantes de dos maneras: utilizando #define o utilizando
::> 3.141593 // no signo igual, no ;
::onst TipoDato NombreConstante = ValorConstante;
rt ...,eses = 12;
=-a: carácter = '$';
:=-sr int luna = 238857; // distancia en millas

:o,_:<< "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

2.6. CARACTERES SECUENCIALES (CODIGOS) DE ESCAPE
Código de Escape Significado

'\n' Nueva línea
'\r ' Retomo de carro
'\t' Tabulación horizontal
'\v' Tabulación vertical
'\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 introduzca su orimera y ultima inicial e j Hola C . J.!
2 introauzca s� oñmera y ultima inicial j R Hola J. R .!
3 Introduzca su p'l:.era y ultima inicial A B Hola A . B.!
4 introduzca su pri-ie:a y ultima inicial X X Hola X. X.!
5 introduzca su prine:-a y ultima inicial s M Hola S .M.!

Pr ramación 39
-,.mplos de programas que incluyen codificación en c++,

a..-cs el ejemplo de convertir Celsius a Fahrenheit, pseudocódigo, d.f. y
Diagrama de Flujo:
(inicio)
-=--- cel
� ·r 'Ingrese grados Celsius: ' t
ee-cel real: cel
�.:>·r 'Fahrenheit= ', (9 / 5) * cel + 32 t
<
/ cel /
t
'Fahrenheit= ', ( 9 / 5 ) * cel + 32
·ca: cel;
::::i__� << ª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

Algoritmos y Programación 4Q
Resolvamos el ejercicio del cuadrado, pseudocódigo, d.f. y codificación en c++:
Pseudocódigo: Diagrama de Flujo:

inicio
real: lad inicio
escribir 'Ingrese lado: '
leer lad real: lad
escribir 'Area= ' , lad * lad
escribir 'Perímetro= ' , 4 * lad
fin lad
Codificación en c++: 'Area= ' , lad * lad

#include < iostream.h > 'Perímetro=' ,4 * lad
void main ()
{ fin
float lad;
cout << "Ingrese lado: ";
cin >> lad;
cout << "Area=" << lad * lad << endl;
cout << "Perímetro= "<< 4 * lad;
}
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 lad Mensaje pantalla
pantalla
1 Ingrese lado: 1 Area= 1
Perímetro= 4
1
Perímetro= 20
i1 Perímetro = 28
A Ingrese lado: 12 Area= 144
1 Perímetro= 48
5 111 Ingrese lado: 23 Area= 259
Perímetro= 92
41
Diagrama de Flujo:
::::rs:ante real pi=3.141593 inicio

""!!a...-ad
es::-:,· 'Ingrese radio: ' constante real pi=3.1411593
ee--ad real: rad
es;:;--.:,·· 'Area=', pi*rad *rad
ese-: · 'Perímetro= ' , 2 * pi* rad rad
'Diámetro= ' , _2*rad

'Area= ' , pi *rad*rad
'Perímetro=' . 2*pi*rad
fin
:::::rs: "-oat pi = 3.14159;
-ao;
:::J • << 'Ingrese radio: ";
::r- >>-ad;
:::i: << 'Diametro= • << pi*rad *rad << endl;
::::i..: << ·Area= " << pi* rad * rad << endl;
:o..:<< "Peri metro= • << 2 * pi*rad;
: ".!. 593
-------=- 5.283184
:ie s·mulación de 2 corridas:
pi Mensaje rad Mensaje pantalla
antalla
3.141593 · Ingrese radio: 1 Diámetro: 2
Area: 3.141593
Perímetro: 6.2831
3.141593 Ingrese radio: 5 Diámetro: 2
Area: 78.5398
Perímetro: 31.415

Ejercicios: Elaborar pseudocódigo, diagrama de flujo y codificació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 calcule y despliegue la suma y el

promedio de dichos números

ramación 43
de Asignación abreviados:
asignación asignación
abreviada no abreviada
m +=n m=m+n
m-=n m=m-n
m*=n m=m*n
m/=n m=m/ n(cociente)
mo/o=n m=m % n(residuo)
*
()
Decrementación
-- n
n-=1
- =- - .. n=n-1

Operadores Relacionales:
Operador Significado Ejemplo

iguala a==b
!= no iguala a!= b
> mayor que a>b
< menor que a<b
>= mayor o igual a a>= b
<= menor o igual a a<= b
Operadores Lógicos:
Y ( and ): &&
O (ar): 11
NEGACIÓN (not):

Pre ramación 45
Ll3RERIA conio.h ( consola input/ output)
• cirScr( ); // borrar pantalla, deja el cursor en posición 0,0

• cireol( ); // borra línea actual desde posición actual al final de la línea
• cprintf( ); // escribe salida con formato en consola (salto= \r\n )
• cscanf( ); // 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 cursor a posición c (columna), f (fila)
• ighvideo( ); // activa caracteres de alta intensidad
• - port, inportb // leer desde puertos de entrada/salida
• - sline( ); // inserta línea en blanco en la posición del cursor
• owvideo( ); // activa caracteres de baja intensidad
• ,ormvideo( ); // reinicializa atributos de texto a valores originales
• outport, outportb // escribe en puerto de entrada/salida
• textbackground( int #color ); // color de fondo
• !extcolor( int #color ); // color de texto visualizado por cprintf y cscanf
• 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
3/of-' \flotante
%i entero
o/os cadena de caracteres (string)
3/ox hexadecimal sin signo
// probando algunas funciones de libreria conio ...
#include <conio.h>
main( )
{
cout << "probando libreria conio ..." << endl;
getch();
textbackground(1 ); clrscr( ); // color de fondo
cout << "probando textbackground ... " << endl;
getch( );
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+\r\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á observar cómo trabajan algunas de

las funciones de la librería conio.h

mación 47
JONES MATEMÁTICAS
bcd.h, complex.h, float.h, math.h, stdlib.h
LIBRERÍA math.h
• · ones Matemáticas:
a:is{ x) // valor absoluto de x

x) // redondea al entero superior
=.oor{ x) // redondea al entero mas próximo
�( x, y ) // residuo de x/y
-;o, x, y ) // potencia: xY
s.=:1( x) // raíz cuadrada de x ( x >= O)
·ones Trigonométricas:
�- ( x) // seno de x (radianes)
c:lS( x) // coseno de x
-::n( x) // tangente de x
asín( x) // arco seno de x
acos( x) // arco coseno de x
.;:an( x) // arco tangente de x
S:Oh( x) // seno hiperbólico de x
cosh( 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

Codificación en C++:
#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++ )
cout << mat[ f] [ c] « ". "; imprime casilla y deja espacio
cout << endl; // salto de linea al terminar de desplegar las columnas
}
getch( );
}
Resultado en pantalla:
º º º
Io 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
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
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
escribir mat[ f) [c)
fin_para
fin_para
fin
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]
fin
// mataleatorios.cpp llenando matriz con numeras aleatorios
#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++ )
---
mat[ f] [e] = random( 50 ); // llenando matriz con números aleatorios
for( f = O; f < 5; f++ )

{
fo r( e = O; e < 5; e++ )
cout « mat[ f] [e]« " "· // imprimiendo matriz
cout << endl;
}
getch();
}
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

,.,._..
Tabla simulando la corrida del anterior programa, primer par de ci clos

llenando mat con números aleatorios entre O v 49:
Corrida f e mat[ f] [e]=
random( 50)
1 o o matf O] O 1 =43
1 matf O] 11 = 9
2 mat[ O l 2 l = 23
3 mat[ O] 31=12
4 matf O] 4 1 = 24
1 1 o matf 1 l O 1 =17
1 1 matf 1 l 1 1 = 24
! 2 matf 1 1 2 l =23
3 matf 1 l 3 l =22
4 matf 1 1 41 = 2
1
1 2 o mat[ 2 l O]= 7
: 1 matf 2 l 1] =30
i 2 mat[ 2 ] 2 J= 20
3 mat[ 2 ] 3 1 = 26
4 matf 2 1 f 41 = 36
3 o matf 3 1 O 1 =37
1 matf 3 l f 1 ] = 36
2 mat[ 3] 2] = 6
3 mat[ 3] 3]= 5
4 mat[ 3 J 4 ] = 26
4 o matf 4 ] f O 1 = 28
matf 4] 1l =33
2 matf 4 1 f 2 l = 12
3 matf 4 1 f 3 l = 35
4 matf 4 l 4] = 5
El resultado en memoria será un número aleatorio entre O y 49 en cada casilla 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. Rodríguez v.

1,
:,:
Otro ejemplo:
Veremos un programa que declara una matriz de 2 filas 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
entero: mat[ 2] [ 3 ], f, c
para e desde O hasta 2 paso 1 hacer
escribir "Ingrese valor·, f, • ,", c, ":"
leer mat[ f][ c ]
fin_para
fin_para
escribir mat[ f] [c ]
fin_para
fin_para
fin 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
Codificación en C ++:
// matusuario.cpp llenando matriz con datos ingresados por usuario
#include <conio.h>
void main()
{
int mat[ 2J [ 31, f,e;
far( f= O; f< 2; f++ )

far(e= O;e < 3;e++ )
{ cout << "Ingrese valor"<< f<< ","<<e<<":";
cin » mat[ f] [eJ;
}
far( f = O; f < 2; f++ )

{
far(e= O;e < 3;e++)
cout << mat[ f] [e]«" "·
cout << endl;
}
getch( );
}
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
10 20 30
40 50 60

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

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.

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
entero: mat1[ 4] [ 4 ], mat2[ 4] [ 4], mat3[ 4] [ 4], f, c

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

escribir mat1[ f J [c]
fin_para
escribir espacio

escribir mat2[ f J [ e]
fin_para
escribir espacio

escribir mat3[ f J [ e ]
fin_para
escribir salto de línea
fin_para
fin

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( 1O )
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

// matsumaaleatorios: suma de matrices aleatorios ...
#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];
}
for( 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( );
}

3 5 5 9 O 6 O 8 3 11 5 17
9 4 2 2 7 6 1 6 16 10 3 8
O 78 5 88 7 7 8 15 15 12
3 1 4 2 O 6 9 6 3 7 13 8
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:
corrida f e mat1[ f1 í e 1 mat2í f l[ e 1 mat3í f líe l
1 o o mat1í O 1 f O 1 = 3 mat2f O 1 í O 1 = O mat3f O 01= 3
1 mat1f O l f 1 1 = 5 mat2f O 1 f 1 1 = 6 mat3f O 1 l =11
2 mat1[ O l [ 2 l = 5 mat2[ O1 f 21 = O mat3f O 21 = 5
3 mat1[ O J [ 31 = 9 mat2[ O l [ 31=8 mat3f O 3]=17
1 o mat1[ 1 ][ O l =9 mat2[ 1 ] f O ]=7 mat3f O 1]=16
1 mat1[ 1] [ 1] =4 mat2[ 1 ] [ 1 J =6 mat3[ 1 1] =10
2 matH 1 1f 21 =2 mat2f 1 l [ 2 ]=1 mat3[ 1 2 1= 3
3 mat1f 1 ][ 3 ]=2 mat2í 1 } [ 3 ] = 6 mat3f 1 31= 8
2 o mat1f 2 lí O l =O mat2f 2 l f O J =8 mat3f 2 01= 8
1 mat1[ 2] [ 1] = 7 mat2[ 2 1 [ 1 l =8 mat3f 2 1]=15
2 mat1[ 2] [ 2 ] = 8 mat2f 2 ][ 2 ] =7 mat3f 2 2] =15
3 mat1[ 2 ] [ 3] = 5 mat2[ 2 ] [ 3 l =7 mat3f 2 3) = 12
3 o mat1f 3 l f O] =3 mat2f 3 l [ O ] =O mat3[ 3 01= 3
1 mat1[ 3 ][ 1 ]=1 mat2f 3 ] [ 1 ] =6 mat3[ 3 11= 7
2 mat1 f 3 l f 2 l =4 mat2f 3 l f 2 1 =9 mat3[ 3 21=13
3 mat1f 3 l f 3 l =2 mat2f 3 l f 3 l =6 mat3f 3 · 3 1= 8
El resultado en memoria serán datos aleatorios entre O y 9 en cada casilla de las

matrices mat1 y mat2 , mat3 es 1 a suma d e mat1 + mat2:
mat col col col col mat col col col col mat col col col col
1 o 1 2 3 2 o 1 2 3 3 o 1 2 3
fila O 3 5 5 9 o 6 o 8 3 11 5 17
fila 1 9 4 2 2 7 6 1 6 16 10 3 8
fila 2 o 7 8 5 8 .8 7 7 8 15 15 12
fila 3 3 1 4 2 o 6 9 6 3 7 13 8

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
entero: mat[ 2 ] [ 3], tra[ 3] [ 2 ], f, c

escribir "Ingrese valor:", f, e
leer mat[ f] [ c]
tra[ c ] [ f] = mat[ f] [ e]
fin_para
fin_para

escribir mat[ f J [c]
fin_para
fin_para

escribir tra[ f 1 [ e]
fin_para
fin_para
fin

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.

// matra.cpp: matriz y transpuesta, pide datos al usuario ...
#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
{
far( e = O; e < 3; e++ )
cout « mat[ f] [e J « "\t"; // mat
cout << endl;
}
cout << "\nDatos de Transpuesta:" << endl;

far( f = O; f < 3; f++ ) // imprimiendo tra
{
far( e = O; e < 2; e++ )
cout « tra[ f J [e] « ''\t"; // transpuesta
cout << endl;
}
getch( );
}

Resultado en antalla:
Ingrese valor O O: 100
Ingrese valor 1 O: 400
Datos de Matriz:
100 200 300
400 500 600
Datos de Transpuesta:
100 400
200 500
300 600
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
fila O 100 200 300
fila 1 400 500 600
. de I os datos asignad os a matnz

El resu tado en memoria . tra
tra columna O columna 1
fila O 100 400
fila 1 200 500
fila 2 300 600

Ejercicios:
Elaborar pseudocódigo, diagrama de flujo y codificación e n 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 generar mat3 como la diferencia 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 generará el 20% de las comisiones que correspondan a cada dato
que el usuario haya ingresado en mat1. Se requiere imprimir ambas
matrices.

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 utilizamos
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 arreglo [número_planos J [ número_filas 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).

Asignar valores:
Ejemplo:
ter:np [ 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 ; >

6.6. MANEJO DE ARREGLOS UTILIZANDO FUNCIONES:
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:

Codificación en e++:
#include <conio.h>
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 arreglo tiene " << n << " elementos, que son:\n";
imprimir( a, n, prom);
cout << "El promedio en main es: " << prom << endl;
getch();
}
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

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 <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( );
far( 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();
}
Resultado en pantalla. El usuario no introduce ninqún dato:
72 16 75 43 68
5 69 44 55 4
26 75 80 93 78
21 49 48 99 69
94 58 31 21 94

6.7. CADENAS DE CARACTERES

C++ no tiene datos predefinidos 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 9
Declarando e inicializando un arreglo de caracteres:

char color [ 1 O] = { 'a' , 'z' , 'u' , 'I' } ; // declarando e inicializando ar. de caracteres
color
1a Iz 1u 11
O 1 2 3 4 5 6 7 8 9
Declarando e inicializando una cadena de caracteres:

char color [] = "azul"; // cadena entre comillas, al final asigna carácter nulo: \O
color
1a Iz
O 1 2 3 4 5 6 7 8 9
Otra manera: escribiendo separadamente cada letra:

char color [] = 'a', 'z' , 'u' , 'I' , '\O' ; // cada carácter entre apóstrofos
color
1a Iz 1u 11 1 \O
O 1 2 3 4 5 6 7 8 9
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
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
cout « "2: " « ptrnombre[ 2] << endl; // despliega p

cout « "3: " « ptrnombre[ 3] << endl; // despliega e
cout << "4: "<< ptmombre[ 4] << endl; // despliega vacio
getch{ );

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 <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 ) ;

La librería string.h contiene muchas funciones para manipular cadenas de

caracteres, veamos algunas:
#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 cambiar valor es un
puntero constante
strcpy(cadena,"Buenos Dias"); // inicializa y copia Buenos Dias en cadena,
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 primera 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

// 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( );
}

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 <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;
11 otro ejemplo: utilizando ciclos si hay muchos tokens

char oracion[ ] = "Esta oracion contiene 5 tokens" 11 declarando e
inicializando
char *separ = " n ;
char *ptrToken = oracion ;
cout << "Utilizando ciclos:" << endl;

cout << "Oracion: " << oracion << endl;
ptrToken = strtok( oracion, separador ) ;
while( ptrToken)
{
cout <<"token:"<< ptrToken << endl;
ptrToken = strtok( NULL, separador) ;
}
getch();
}
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: En c++:
estructura inventario struct inventario

inicio
carácter titulo [ 25 1 ; char titulo[ 25 J;
carácter autor [ 30 1 ; char autor[ 30 J;
entero num; int num;
real precio_venta; float precio_venta;
fin };
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
Aur:ique 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
ser, en genera11 'taxis
, a sm .. de una estructura as,:.
' de creac1on
pseudocódigo diagrama de flujo codificación c++
estructura nombreestructura estructura nombreestructura struct nombreestructura

inicio inicio {
tipo campo tipo campo tipo campo
... ... ...
fin fin };

Ejercicios:
Definir al menos 5 campos o miembros para las estructuras siguientes:
• _Empleados
• Alumnos
• Clientes

Declaración de tipos estructura:
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
libro.título libro.autor libro.num libro.precio_venta
En general. la sintaxis del manejo de un campo dentro del programa es:
nombredatoestructura.nombrecampo
.)
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.

Ejemplo:
En el siguiente programa, veremos el manejo de una estructura, que consiste en
definirla o crearla, declararla, asignarle datos y accesar a sus datos.
Pseudocódigo: Diagrama de Flujo:
estructura inventario // definiendo o creando estructura: inicio

inicio
carácter titulo[ 25 ] estructura inventario
carácter autor[ 30 ] inicio
entero num carácter título[ 25 ]
real precio_venta carácter autor( 30 ]
fin entero num
re31 precio_venta
inicio fin
inventario libro; // declarando inventario libro
// pidiendo datos al usuario (asignando valores) ...

escribir "Titulo del libro: "
leer libro.titulo
escribir "Autor: "
leer libro.autor libro.título
escribir "Numero: " libro.autor
leer libro.num libro.número
escribir "Precio de venta:" libro.precio_venta
leer libro.precío_venta
// ahora desplegamos (accesando valores) ...
escribir "Los datos ingresados:" "Los datos ingresados:"

escribir libro.titulo libro.título
escribir libro.autor libro.autor
escribir libro.num libro.número
escribir libro.precio_venta libro.precio_venta
fin fin
..
Codificación en e++
{¿- En c++ se pueden asignar datos al declarar la estructura ( entre llaves ).
// prestruc.cpp probando estructuras...

#include <iostream>
#include <conio>
#include <stdio> // contiene gets
struct inventario
{
char titulo[ 25 ] ;
char autor[ 30 ] ;
int num;
float precio_venta;
} libro = { "Programacion en C++", "Luis Jayanes", 50,250.75};
void main()
{
//inventario libro; // también se puede declarar dentro del programa
// pidiendo datos al usuario ( asignando valores) ...
cout « "\nTitulo del libro:";
· gets(libro.titulo);
cout << "\nAutor: ";
gets( libro.autor);
cout << "\nNumero: ";
cin >> libro.num;
cout << "\nPrecio de venta:";
cin >> libro.precio_venta;
//libro.precio_venta=300.75; // otra forma de asignar valor
// termino ingreso de datos, ahora desplegamos ( accesando a valores) ...

cout << "\nlos datos ingresados son:\n";
cout << libro.titulo << endl;
cout << libro.autor << endl;
cout << libro.num << endl;
cout << libro.precio_venta << endl;
getch{ );
}

Título del libro: Precálculo

Autor: James Stewart
Número: 200
Precio de venta: 450.25
Los dados ingresados son:

Precálculo
James Stewart
200
450.25
En memoria:

Precálculo James Stewart 200 450.25
libro.título libro.autor libro.num libro.precio_venta
Ejercicio:
Elaborar un programa que defina una estructura que contenga los siguientes
mtembros: código (1 O caracteres), nombre(20 caracteres), unidades (entero),
costo (real). Dentro del programa, declare la estructura, pida datos al usuario y
seguidamente despliéguelos.

6.8.2. ESTRUCTURAS ANIDADAS

Se refiere a una estructura como un miembro de otra o una estructura dentro de
otra.
Ejemplo:
Se requiere registrar información de personas con los siguientes datos:
Código, nombre, altura, peso, fecha_nacimiento,
Pero la fecha de nacimiento a su vez consta de dia, mes, año por lo que se
define como una estructura y ésta quedará anidada dentro de la estructura
anterior.
.
p odriamos representar 1a as1:
códi¡:¡o nombre altura oeso fecha
1 dia I mes I anio 1
1 1 1 1
Se define primero la estructura más interna y después la externa.
estructura Fecha
inicio
entero día
entero mes
entero año
fin
estructura Persona
inicio
entero código
carácter nombre[ 20 ]
real altura
real peso
Fecha fec
fin
Dentro del programa se declara una variable ( por ejemplo pe que es de tipo
Persona)
Persona pe
Los miembros se manejan dentro del programa así:
pe.código
pe.nombre
Los que están anidados ( dentro del miembro fec ), se manejan así:
pe.fec.dia
pe.fec.mes
No hay límite de anidaciones, se pueden utilizar varios niveles y números de

anidación.

Veamos el siguiente programa completo:

Pseudocódigo Diagrama de Flujo
estructura Fecha
( ini�io)
inicio
entero dia
entero mes estructura Fecha
entero anio inicio
fin entero día
entero mes
estructura Persona entero anio
inicio fin
entero código estructura Persona
carácter nombre[ 20 ] inicio
real altura entero código
real peso carácter nombre[20]
Fecha fec; // fec es de tipo Fecha real altura
fin real peso
inicio Fecha fec
Persona pe; // declarando pe tipo Persona fin
. escribir "Ingrese codigo: " Persona pe
�----�------'
leer pe.codigo
escribir "Ingrese nombre: "
pe.código
leer pe.nombre
pe.nombre
escribir "Ingrese altura: "
pe.altura
leer pe.altura
pe.peso
escribir "Ingrese peso: "
pe.fec.dia
leer pe.peso;
pe.fec.mes
escribir "Ingrese dia: "
pe.fec.anio
leer pe.fec.dia
escribir "Ingrese mes: "
leer pe.fec.mes "Los datos ingresados:"
escribir "Ingrese anio: " pe.código,
leer pe.fec.anio pe.nombre,
escribir "Los datos ingresados:" pe.altura,
escribir "Codigo : " , pe.codigo pe.peso,
escribir "Nombre: " , pe.nombre pe.fec.dia,
escribir "Altura : " , pe.altura oe.fec.mes.
escribir "Peso : " , pe.peso
escribir "Fecha : ",pe.fec.dia,"/",pe.fec.mes,"/",pe.fec.anio
fin ,,---'-�
fin
Codificación e++
#include <iostream>
#include <conio>
#include <stdio>
struct Fecha
{
unsigned int día; // enteros positivos
unsigned int mes;
unsigned int anio;
};
struct Persona
{
long codigo;
char nombre[20J;
float altura;
float peso;
Fecha fec; // dato fec es de tipo Fecha ( estructura )
};
void main()
{
Persona pe; // declarando variable pe tipo Persona que contiene fec
cout << "Ingrese codigo: "; cin >> pe.codigo;
cout << "Ingrese nombre:"; gets(pe.nombre);
cout << " Ingrese altura: "; cin >> pe.altura;
cout << "Ingrese peso: "; cin >> pe.peso;
cout << "Ingrese dia:";cin >> pe.fec.dia;
cout << "Ingrese mes: "; cin >> pe.tac.mes;
cout << "Ingrese anio: "; cin >> pe.fec.anio;
cout << "\n\nlos datos ingresados son:" << endl;
cout << "Codigo : "<< pe.codígo << endl;
cout << "Nombre: "<< pe.nombre << endl;
cout << "Altura : "<< pe.altura << endl;
cout << "Peso : " << pe.peso << endl;
cout << "Fecha : "<< pe.fec.dia << "f' << pe.fec.mes << "/" << pe.fec.anio;
getch( );
}

Libro Algoritmos PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Libro Algoritmos PDF

Загружено:

Авторское право:

Доступные форматы

PRIMERA EDICIÓN, Enero de 2009

SEGUNDA EDICIÓN, Enero de 2010

DERECHOS DE AUTOR REGISTRADOS ®

G... .;a,w..A, C. A., 2010.

A Dios, por todas las bendiciones recibidas y por recibir.

A mis padres y hermanos, 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.

La intención del presente libro, es la de presentar un texto práctico y sen�llo

E.n este libro nos enfocaremos a la programación orientada a procedimientos

Deseo recalcarle que /a programación es una habilidad que adquirirá con

3. ESTRUCTURAS SELECTIVAS O ALTERNATIVAS ( CONDICIONES )...48

5. PROGRAMACION MODULAR ( FUNCIONES Y PROCEDIMIENTOS ).129

6. ESTRUCTURAS DE DATOS....................................................., .............150

-ciaremos nuestro estudio con algunas definiciones generales:

.1. LAS PARTES DE UN SISTEMA DE COMPUTO

=>orlo tanto, INFORMACION implica datos procesados y organizados.

Inga. Jenny M. Rodrfguez V.

Ejemplos de algoritmos de la vida diaria:

Cambiar bombilla quemada en el techo:

Elabore usted los siguientes algoritmos:

• Cambiar vidrio roto de una ventana

Inga. Jenny M. Rodríguez V.

.3. ETAPAS EN LA SOLUCION DE UN PROBLEMA

• .,:es de escribir un programa, el programador debe entender el problema con

_as fases o etapas de resolución de un problema con computadora son:

• ANALISIS: El problema se analiza según los requerimientos de quien

• DISEÑO: Una vez analizado el problema, se diseña una solución que

• CODIFICACION ( IMPLEMENTACION }: El algoritmo lleva a escribir un

• COMPILACION: El programa se compila, se eliminan los errores de sintaxis

• EJECUCION Y VERIFICACION: Se comprueba que produzca los

• DEPURACION Y MANTENIMIENTO: El programa se modifica cada vez

• DOCUMENTACION: Escritura de las diferentes fases del ciclo de v_ida del

Inga. Jenny M. Rodríguez V.

• Intérpretes: Traducen una línea, si no hay error la ejecutan y continúa así

• Compiladores: Traduce el total de todas las líneas, si hay error, despliega

.7. TIPOS DE INSTRUCCIONES

.8. DATOS, TIPOS DE DATOS

• Numéricos Enteros (sin decimales)

• Lógicos Verdadero (true)

• Carácter a,b,c, ... A,B, C, ... (letras)

Inga. Jenny M. Rodríguez V.

También los datos se pueden clasificar como:

• Constantes (no cambian su valor durante la ejecución de todo el programa),

• 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

• Estructurados ( conjunto de casillas de memoria como los arreglos ).

1.9. MEMORIA E IDENTIFICADORES

Un identificador es el nombre que se le da a las casillas de memoria a utilizar y se

3. � ::a-_ -::e::=-- ce':>e ser representativo del uso que se le dará

Inga. Jenny M. Rodríguez V.

�::;r ejemplo si declaramos la variable edad, reservamos 4 bytes en los que

5 declaramos la variable nombre, reservamos unos 30 bytes para guardar

= declaramos la variable sueldo, reservamos 4 bytes para guardar valores

s· éeclaramos la variable x, no tendremos idea de lo que guardaremos en dicho

!._ aeclarar dichas variables, en memoria se podrían representar así:

Inga. Jenny M. Rodríguez V.

Al asignar valor a dichas variables, en memoria se podría representar así:

1.11. FUNCIONES INTERNAS

Inga. Jenny M. Rodríguez V.

1• 2. JERARQUIA DE LAS OPERACIONES MATEMÁTICAS

Operadores div y mod:

• expresión aritmética: x = _1�-- algorítmica: x = 1 / y