C

UNIVERSIDAD TCNICA DE AMBATO
FACULTAD DE CIENCIA HUMANAS DE LA

EDUACIN
DOCENCIA EN INFORMTICA
aaaaa
C++ 2
C++
Cuaderno digital
Contenido
ELEMENTO 1 ............................................................................................................................... 9
TURBO C ++ ................................................................................................................................ 9
TURBO C ++ ........................................................................................................................... 10
Breve historia ........................................................................................................................ 10
CARACTERSTICAS DE C++ ..................................................................................................... 10
OPERADORES EN C++............................................................................................................ 11
Tipos de datos en C++........................................................................................................... 12
Tipos de datos simples ......................................................................................................... 14
FUNCIONES ........................................................................................................................... 14
La funcin main() .............................................................................................................. 14
Funciones de E/S bsicas .................................................................................................. 15
La funcin scanf ................................................................................................................ 15
La funcin printf ................................................................................................................... 15
LIBRERAS Y FUNCIONES ....................................................................................................... 16
Aaaaa
Ashqui Israel
C++ - Ashqui Israel 3

stdio.h ............................................................................................................................... 16
conio.h............................................................................................................................... 16
getch(); Declaracin de variables ........................................................................................ 18
SINTAXIS DE LAS SENTENCIAS Y FUNCIONES DE C ............................................................... 19
SENTENCIA DE ASIGNACION ................................................................................................. 19
ENTRADA Y SALIDA ESTANDAR............................................................................................. 20
Sentencia if........................................................................................................................ 20
WHILE:.................................................................................................................................. 21
DO WHILE: ............................................................................................................................ 22
CREACIN DE BUCLES ANIDADOS ........................................................................................ 23
SWITCH: ................................................................................................................................ 24
} ............................................................................................................................................. 26
SENTENCIA FOR .................................................................................................................... 26
Contador: .............................................................................................................................. 27
Acumulador: ......................................................................................................................... 28
FUNCIONES C++ .................................................................................................................... 28
Vectores, Matrices y Punteros en c++...................................................................................... 29
VECTORES ............................................................................................................................. 29
MATRICES.......................................................................................................................... 31
PUNTEROS ........................................................................................................................ 32
ARITMTICA DE PUNTEROS .............................................................................................. 34
VECTORES DINMICOS ......................................................................................................... 35
MATRICES Y PUNTEROS .................................................................................................... 36
MATRICES DINMICAS ...................................................................................................... 37
ELEMENTO 2 EJERCICIOS C++ ................................................................................................... 39
SENTENCIA IF ........................................................................................................................ 39
Programa N.-1 . - Disee un programa que me permita ingresar 3 nmeros
enteros desde teclado que corresponden a 3 notas las mismas que deben
estar entre 1 y 10, obtenga el promedio correspondiente y determine su
equivalencia. ..................................................................................................................... 39

Anlisis: .......................................................................................................................... 40
PROGRAMA N.-2.- Disee un programa que me permita ingresar un nmero
entero desde teclado desde 1 al 7 y que determine o visualice el nombre del da
de la semana que corresponda ....................................................................................... 42
ANALISIS: .......................................................................................................................... 42
PROGRAMA N.-3.- Disee un programa que me permita obtener las comisiones
de ventas de la empresa XYZ, Bajo los siguientes condicionamientos si el valor
de la venta es igual a .......................................................................................................... 46
ANALISIS: .......................................................................................................................... 46
CODIFICACION: ............................................................................................................ 46
PROGRAMA N.-4.- Disee un programa que me permita ingresar 2 nmeros por
teclado y realizar la suma de los mismos. ................................................................... 49
ANALISIS: .......................................................................................................................... 50
CODIFICACION: ............................................................................................................ 50
PROGRMA N.-5 Realice la suma de 2 nmeros siempre que el primer valor este
entre 3 y 23 y el segundo valor este entre 5 y 17. ...................................................... 51
ANALISIS: .......................................................................................................................... 51
PROGRAMA N.-6. Disee un programa que me permita ingresar el nombre de
una persona y la edad de la misma que debe estar entre 3 y 85, para obtener
las siguientes equivalencias: ........................................................................................... 54
ANALISIS: .......................................................................................................................... 54
CODIFICACION: ............................................................................................................ 54
PROGRAMA 7. Disee un programa que me permita simular la venta de productos
en una factura, de la cual necesitamos ingresar el nombre del producto, la
cantidad, precio unitario y calcular el precio total. El programa se repite n veces
segn los productos que el usuario desee ingresar. ..................................................... 57
ANALISIS: ............................................................................................................................ 57
PROGRAMA N.-9 Disee un programa que me permita calcular el promedio
general de las notas de distintas materias correspondientes al 2 Semestre de
Docencia en Informtica, en donde cada una de las notas ingresadas debe estar
entre 1 y 10. ........................................................................................................................... 59
Anlisis: ........................................................................................................................... 59

PROGRAMA N.-9 Realice un programa en C++ que me permita obtener el lquido a
recibir de un empleado bajo los siguientes parmetros: ............................................. 61
ANALISIS: ............................................................................................................................ 62
CODIFICACION: .............................................................................................................. 62
PROGRAMA N.-10. Disee un programa que me permita imprimir un borde de
pantalla. .................................................................................................................................. 66
ANALISIS: ............................................................................................................................ 66
CODIFICADO: .................................................................................................................. 66
PROGRAMA N.-11.- Disee un programa que me permita imprimir un borde de
pantalla .................................................................................................................................... 68
Anlisis: Este programa nos permite generar un margen o borde en pantalla
para mejorar la presentacin en pantalla. .................................................................. 68
Codificacin: ................................................................................................................... 69
PROGRAMA N.-12.- Disee un programa que me permita visualizar la serie de los
nmeros pares ......................................................................................................................... 70
Anlisis: este programa nos va a generar el borde en pantalla as como tambin
generara los nmeros pares ingresando un lmite ingresando desde teclado. .. 70
Corrido: ........................................................................................................................... 70
nmeros pares y los impares que existen hasta el nmero lmite ingresado desde teclado.
.................................................................................................................................................. 72
ANALISIS: este programa nos ayuda a generar nmeros pares e impares y a la
vez nos genera el borde. .................................................................................................. 72
Codificacin: ................................................................................................................... 72
PROGRAMA N.-14.- Disee un programa que me permita generar las tablas de
multiplicar de cualquier factor ingresado desde teclado y por cualquier limite
ingresado desde teclado, el programa se genera n veces, disee el borde en
pantalla. .................................................................................................................................. 74
ANALISIS: este programa genera el borde como tambin genera la tabla de
multiplicar ingresando por teclado el nmero y el lmite. ...................................... 74
Codificacin: ................................................................................................................... 75
Programa 15 .......................................................................................................................... 76
Enunciado: ............................................................................................................................ 76

Codificado ......................................................................................................................... 76
4.-Analisis del Programa: .................................................................................................. 78
Programa 16 ......................................................................................................................... 78
Programa 17 ......................................................................................................................... 80
Programa 18 ......................................................................................................................... 81
Programa 19 ......................................................................................................................... 82
PROGRAMA N.-21. -Disee un programa que me permita generar la siguiente
serie de datos: primos en el numerador e impares en el denominador.} ................ 84
CODIFICADO ....................................................................................................................... 84
ANALISIS.......................................................................................................................... 86
PROGRAMA N.-22.-disee un programa que me permita generar la siguiente serie
de datos: como numerador los nmeros impares y como denominador la serie
fibonasi. .................................................................................................................................. 86
CODIFICADO: ...................................................................................................................... 86
ANALISIS.......................................................................................................................... 88
PROGRAMA N.-23.- Disee un programa que me presente un men de opciones
con las operaciones bsicas, estas son suma, resta, multiplicacin, divisin y una
opcin para salir del programa. ........................................................................................ 88
CODIFICACION: .................................................................................................................. 88
ANALISIS.......................................................................................................................... 91
PROGRAMA N.24.- Disee un programa con un men de opciones que me
permita calcular las reas y permetros de las 4 figuras bsicas: circulo, cuadrado,
triangulo, rectngulo. .......................................................................................................... 93
CODIFICACION: .................................................................................................................. 93
} ......................................................................................................................................... 96
ANALISIS.......................................................................................................................... 96
Programa 25 .......................................................................................................................... 98
ANLISIS ............................................................................................................................. 98
CODIFICADO: .................................................................................................................. 98
Programa 26 ........................................................................................................................ 101
Analisis: ............................................................................................................................ 102

Codificacin: ................................................................................................................. 102
Programa 27 ........................................................................................................................ 105
Anlisis : ............................................................................................................................ 105
Codificacin: ................................................................................................................. 105
Programa 28 ........................................................................................................................ 108
Codificado:........................................................................................................................ 109
Programa 29 ........................................................................................................................ 110
Anlisis: ............................................................................................................................ 110
Codificacin: ................................................................................................................. 110
Programa 30 ........................................................................................................................ 112
Analisis: ............................................................................................................................ 112
CoDIFIcado: .................................................................................................................. 112
Programa 32 ........................................................................................................................ 116
CODIFICADO: ....................................................................................................................... 116
ELEMENTO 3 ........................................................................................................................... 119
ELEMENTO 4 ........................................................................................................................... 120
Funciones vectores matrices .............................................................................................. 120
PROGRAMA 33..................................................................................................................... 121
1. ENUNCIADO .................................................................................................................. 121
2. ANALISIS ....................................................................................................................... 121
3. DOCUMENTACION ....................................................................................................... 121
4. CORRIDO DEL PROGRAMA ........................................................................................ 123
PROGRAMA 34..................................................................................................................... 124
1. ENUNCIADO .................................................................................................................. 124
2. ANALISIS ....................................................................................................................... 124
3. DOCUMENTACION ....................................................................................................... 124
4. CORRIDO DEL PROGRAMA ........................................................................................ 125
Programa 35 ....................................................................................................................... 126
ENUNCIADO .................................................................................................................... 126
Programa 36 ....................................................................................................................... 130

Programa 37 ....................................................................................................................... 134
Programa 38 ....................................................................................................................... 138
Programa 38 ....................................................................................................................... 141
Programa 39 ....................................................................................................................... 150
Programa 40 ....................................................................................................................... 153
Programa 42 ....................................................................................................................... 156
Programa 43 ....................................................................................................................... 160
Programa 44 ....................................................................................................................... 162
Programa 45 ....................................................................................................................... 166
Programa 46 ....................................................................................................................... 168
Programa 46 ....................................................................................................................... 170
PROGRAMA 48.................................................................................................................... 175
PROGRAMA 49.................................................................................................................... 179
Programa 50 ....................................................................................................................... 182
programa51 ........................................................................................................................ 186
Programa 52.-................................................................................................................... 188
Programa 53 ....................................................................................................................... 191
PROGRAMA 54 .......................................................................................................... 194
Programa 55 ....................................................................................................................... 197
Programa 56 ....................................................................................................................... 198
Programa 57 ....................................................................................................................... 202
Programa 58 ....................................................................................................................... 204
Programa 59 ....................................................................................................................... 207
Programa 60 ....................................................................................................................... 209
Programa 61 ....................................................................................................................... 212
Programa 62 ...................................................................................................................... 218
BIBLIOGRAFIA: ................................................................................................................ 220
ELEMENTO 1
TURBO C ++
C++ comenz a desarrollarse en 1980 en los laboratorios de la Ca. AT&T. Es una
ampliacin del lenguaje C. El nombre C++ proviene del operador incremento ++.
Es un lenguaje potente, verstil y es muy importante para empezar a aprender a
programar. Sus principales caractersticas son:
Programacin estructurada, Abundancia de operadores y tipos de datos, riqueza y
flexibilidad en las expresiones, sobrecarga de funciones y operadores
TURBO C ++
Breve historia
El lenguaje C fue inventado por Dennis Ritchie en 1972 cuando trabajaba, junto con
Ken Thompson, en el diseo del sistema operativo UNIX.
El lenguaje C deriva del lenguaje B de Thompson, el cual, a su vez, deriva del
lenguaje BCPL desarrollado por Martin Richards. Durante muchos aos el estndar
de C fue la versin proporcionada con el sistema operativo UNIX versin 5. Pero
pronto empezaron a surgir muchas implementaciones del C a raz de la popularidad
creciente de los microordenadores. Por este motivo, se hizo necesario definir un C
estndar que est representado hoy por el ANSI C.
En este tutor se va a estudiar el C estndar. No obstante, si la opcin turbo est
activada, tambin se incluir en la explicacin la versin Turbo C de Borland
International, que es uno de los mejores compiladores de C que existen en el
mercado.
Cuando nos referimos a Turbo C, estamos hablando indistintamente de las distintas
versiones que existen sobre los paquetes Turbo C, Turbo C++ y Borland C++,
puesto que en todos ellos se puede programar en C.
El lenguaje C suministrado por Turbo C es, simplemente, una ampliacin del ANSI
C, sobre todo en el nmero de funciones de librera suministradas.
CARACTERSTICAS DE C++
El nombre C++ fue propuesto por Rick Mascitti en el ao 1983, cuando el

lenguaje fue utilizado por primera vez fuera de un laboratorio cientfico. Antes
se haba usado el nombre "C con clases". En C++, la expresin "C++"
significa "incremento de C" y se refiere a que C++ es una extensin de C.
Programacin de bajo nivel (nivel bit).
Lenguaje estructurado.
Tiene un conjunto completo de instrucciones de control.
Permite la agrupacin de instrucciones.
Tamao pequeo.
Comandos breves (poco tecleo).
El generar programas eficientes.
Un punto en contra es que tiene una deteccin pobre de errores, lo cual en

ocasiones es problemtico para los principiantes.
La posibilidad de poder ser compilado en una variedad de computadoras, con

pocos cambios (portabilidad).
OPERADORES EN C++
Smbolos que nos ayudarn a relacionar y manipular lo operando,
Lgicos
Aritmticos
Relacionales
Y- AND -&&
O- OR - ||
Asignacin
=
Suma
+
Resta
Multiplicacin *
Divisin
/
Divisin modular%
Incremento
++
Decremento
--
NO- NOT - !
Igual que
==
Menor que
<
Mayor que
>
Menor o igual
que
<=
Mayor o igual
que
>=
Diferente que !=
Tipos de datos en C++

Los tipos de datos primitivos en C++ son: numricos enteros, numricos reales, tipo
lgico y tipo carcter ampliado.
Tipos de datos C++ numricos enteros
El tipo de dato numrico entero es un subconjunto finito de los nmeros enteros del
mundo real. Pueden ser positivos o negativos.
En C++ los tipos de datos numricos enteros son los siguientes:
Tipo
Dato
short
de Descripcin
Entero corto
Nmero
de Rango
bytes tpico
2
-32768 a 32767
int
Entero
long
Entero largo
char
Carcter
-2147483648
+2147483647
-2147483648
+2147483647
-128 a 127
a
a
Con los tipos enteros pueden utilizarse los calificadores signed y unsigned. Estos
calificadores indican si el nmero tiene signo o no. Si se usan solos, sin indicar el
tipo de dato se asume int.
Por ejemplo, las siguientes declaraciones son equivalentes:
unsigned int x;
equivale a:
unsigned x;
Usando estos calificadores podemos tener los siguientes tipos enteros:
Tipo de Dato
Descripcin
signed short
Entero corto
unsigned
short
signed int
Entero
signo
Entero
unsigned int
corto
Nmero
Rango
de bytes
tpico
2
-32768 a 32767
sin 2
0 a 65535
-2147483648 a +2147483647
Entero sin signo
0 a 4294967295
signed long
Entero largo
-2147483648 a +2147483647
unsigned
long
signed char
Entero largo
signo
Carcter
unsigned
char
Carcter sin signo
sin 4
0 a 4294967295
-128 a 127
0 a 255

Podemos ver que los datos enteros de tipo signed son equivalentes a los enteros sin
utilizar el calificador:
signed int a;
es equivalente a escribir
int a;
Tipos de datos numricos reales.

El tipo de dato numrico real es un subconjunto finito de los nmeros reales. Pueden
ser positivos o negativos.
En C++ los tipos de datos numricos reales son los siguientes:
Tipo
de
Dato
float
Doubl
e
long
doubl
e
Descripcin
Nmero
Rango
de bytes
tpico
Real (Nmero en 4
Positivos: 3.4E-38 a 3.4E38
coma flotante)
Negativos: -3.4E-38 a -3.4E38
Real doble(Nmero 8
Positivos: 1.7E-308 a 1.7E308
en coma flotante de
Negativos: -1.7E-308 a -1.7E308
doble precisin)
Real doble largo
10
Positivos: 3.4E-4932 a 1.1E4932
Negativos:
-3.4E-4932
a
1.1E4932
Tipo lgico
Los datos de este tipo slo pueden contener dos valores: true false (verdadero
falso).
Si se muestran como enteros, el valor true toma el valor 1 y false el valor 0.
Tipo
de
Dato
bool
Descripcin
Dato de tipo lgico
Nmero
Rango
de bytes
tpico
1
0, 1
Tipo carcter extendido

Este tipo se utiliza para representar caracteres UNICODE. Utiliza 2 bytes a diferencia
del tipo char que solo utiliza 1.
Tipo
Descripcin
de
Dato
wchar_ Carcter Unicode
t
Nmero
Rango
de bytes
tpico
2
0 a 65535
Tipos de datos simples

Los tipos de datos simples en C son:
void: Tipo de dato que no tiene valor.

int: Para todo el rango de valores enteros*.
float: Para todo el rango de valores reales*.
char: Datos de tipo carcter.
FUNCIONES
Las funciones son un conjunto de instrucciones que realizan una tarea especfica. En general
toman ciertos valores de entrada, llamados parmetros y proporcionan un valor de salida o
valor de retorno; aunque en C++, tanto unos como el otro son opcionales, y pueden no existir.
Tal vez parezca un poco precipitado introducir este concepto tan pronto en el curso. Sin
embargo, las funciones son una herramienta muy valiosa, y como se usan en todos los
programas C++, creo que debemos tener, al menos, una primera nocin de su uso. A fin de
cuentas, todos los programas C++ contienen, como mnimo, una funcin.
La funcin main()
La funcin main() en un programa en C significa el cuerpo del programa o el
programa principal, ya que es la primer funcin que el enlazador busca para
ejecutar; si la funcin main() no tiene parmetros, significa que solamente la
utilizaremos para decirle al programa cundo y cmo debe hacer las cosas, pero, si

tiene parmetros, es decir, si desde la lnea de comando se llama con valores de
entrada, la cosa cambia, y nos ocuparemos de la funcin main() con parmetros
ms adelante.
Funciones de E/S bsicas

Las funciones de E/S son las que se utilizan para capturar datos desde el teclado e
imprimirlos por medio de la salida estndar (monitor). Estas instrucciones soportan
ciertos formatos:
La funcin scanf
La funcin scanf captura cualquier tipo de dato introducido por el teclado, y para
esto, es necesario incluir en su llamada a funcin el formato o tipo de dato que se
pretende leer por teclado, ejemplo:
scanf(%d,&x);
En este caso, se especifica una entrada de tipo decimal o entero (%d), mientras
que el operador de direccin (&) indica que se debe guardar el valor en la localidad
de memoria x, en otras palabras, indica que se recibir un valor entero y se debe
almacenar en la variable x. Ahora bien, los tipos de formato ms usados para la
instruccin scanf son:
%d,
%i
%f
%c
%s
%u
Entero decimal con

signo
Nmero real o flotante
Dato tipo caracter
Dato tipo cadena
Sin signo
La funcin printf
La funcin printf es la contraparte de la funcin scanf, ya que mientras scanf lee
datos desde el teclado, la funcin printf los escribe, es decir, provee la salida en
pantalla, esta funcin tambin utiliza los formatos de scanf, con la particularidad de
que printf puede modificar la salida de los datos, por ejemplo, si se declara una
variable entera, y se le asigna el valor 65, y al momento de imprimir el valor de la
variable se especifica una salida de tipo caracter, la salida ser el caracter A (el 65
equivale a la letra A en el cdigo ASCII).
scanf(%d,&x); /* Se lee la variable como entera */

printf(%c,x); /* Se escribe como caracter */
LIBRERAS Y FUNCIONES
Las libreras son archivos que en C contienen las funciones que son las acciones que C nos
permite hacer estas son las libreras ms usadas por que son libreras estndares de entrada
y salidas de datos tenemos la libreras.
stdio.h
se agrega asi:
#include<stdio.h>
Esta trae muchas funciones son estas (para acceder a la ayuda de turbo c ah se puede
encontrar mucha informacin debes presionar F1 o sombrear una palabra y presionar ctrl +
F1 y te aparecer la ayuda en relacin a la palabra sombreada).
Otra funcin muy usada es la funcin scanf esta nos sirve para leer una variable (pedir un
valor al usuario) su sintaxis es as:
scanf("%d",&X);
x es la variable a la cual le vas a asignar el valor que se esta leyendo y en %d debe ser el tipo
de archivo que se quiere leer. Otra librera que tambin nos servir de mucha utilidad es
conio.h
recuerda que las libreras se agregan al programa as:
#include<conio.h>
Esta librera trae estas funciones:
De las cuales las mas utilizadas son:

Clrscr
Esta funcin nos sirve para limpiar lo que este en la pantalla de nuestro programa
casis siempre lo debe llevar un programa para que no se acumulen los textos su
sintaxis es as:
clrscr();
cprintf esta es parecida a la funcin printf con la diferencia que esta es un poco mas
especial por ejemplo cuando le ponemos el modificador de texto \n no regresa al principio
de la lnea sino se queda en al final del ultimo prrafo (tendrs que hacer pruebas para
entenderlo mejor) o si antes le antepones la funcin textcolor puedes modificar el color de
las letras.

su sintaxis es:
cprintf("texto");
sintaxis con la funcin textcolor
textcolor(numero);
cprintf(texto);
en donde dice numero puede ir un numero del 1 al 15, por ejemplo el numero 9 es el
color rojo.
La funcin getch sirve para detener la pantalla sin esta funcin no se puede apreciar
el programa por que pasa demasiado rpido pero, con getch para el programa para
apreciar el resultado hasta que se preciene una tecla normalmente va antes de
terminar el main .
su sintaxis es la siguiente:
getch();
Declaracin de variables
Es necesario declarar las variables que se utilizarn en el programa, de modo que el
compilador reserve un espacio en memoria para esas variables, la sintaxis es:
[tipo] [nombre_de_la_variable] [[dimension]] ; (la dimensin slo se usa para
arreglos).
Ejemplo:
int x;
int arreglo [100];
Y ya que hablamos de variables, cabe mencionar que las variables pueden ser
declaradas globales o locales, solamente como referencia, las variables globales
son aquellas variables que conservan su valor durante la ejecucin de todo el
programa y se declaran antes del main(), mientras que las variables locales
solamente tienen valor durante la ejecucin de la funcin o procedimiento en que
fueron declaradas y se declaran despus de la llave que indica el principio de una
funcin o procedimiento. De cualquier manera, las diferencias entre las variables
locales y globales sern objeto de estudio ms adelante.
SINTAXIS DE LAS SENTENCIAS Y FUNCIONES DE C

Para presentar los formatos de las sentencias, macros y funciones de C, se
aplicarn, Cuando se trate de presentar la sintaxis correspondiente a una macro o a
una Funcin, se dar la siguiente informacin:
1. Fichero de cabecera que contiene las declaraciones y definiciones relativas a

esa funcin y afines.
78 cunso DE PRocRAMACIN c/c++
2. Prototipo de la funcin para indicar el tipo del resultado y el nmero y tipo de
los argumentos.
3. Compatibilidad (ANSI, UNIX, MS-DOS).
Por ejemplo, la sintaxis de la funcin sqrt (raz ctadrada) es:
#include <math.h> fichero de declaraciones y definiciones
double sqrt(double x); prototipo de 1a funcin
CompaLibilidadz ANSL, UNIX y MS-DOS
SENTENCIA DE ASIGNACION
Una sentencia de asignacin tiene la forma:
Variable e operador-de-asignacin expresin la sentencia de asignacin es
asimtrica. Esto quiere decir que se evala la expresin de la derecha y el resultado
se asigna a la variable especificada a la izquierda.
Por ejemplo:
totaf = O;
area-3.I4L592*T*Ti
cuenta += 1;
Segn lo expuesto, la siguiente sentencia no sera vlida:

3.L4L592*r*r=drdi
Si la variable es de Lipo puntero, solamente se le puede asignar una direccin
de memoria, la cual ser siempre distinta de 0. Un valor 0 (se simboliza con
NULL) sirve para indicar que esa variable puntero no apunta a un dato vlido.
Por ejemplo:
i=10,*p;
P=&a; /* se asigna a p la direccin de a * /

No tiene sentido asignar un entero a una variable de tipo puntero. Cuando se asigna
un valor a una variable estamos colocando el valor en una localizacin de memoria
asociada con esa variable.
a -- 20:
ENTRADA Y SALIDA ESTANDAR
Las operaciones de entrada y de salida (E/S) no forman parte del conjunto de sentencias de
C, sino que pertenecen al conjunto de funciones de la biblioteca estndar de C. Por ello, todo
fichero fuente que utilice funciones de E/S correspondientes a la biblioteca estndar de C,
necesita de los prototipos de las funciones correspondientes a stas, por lo que deber
contener la lnea:
#include "stdio.h"
Las dobles comillas significan que el fichero especificado, debe ser buscado en el directorio
actual de trabajo y si no se encuentra, la bsqueda debe continuar en el directorio estndar
para los ficheros con extensin ./z (directoio include). Si el fichero de cabecera especificado,
en lugar de escribirlo entre comillas, lo escribimos entre nulos:
#include <stdio.h>
la bsqueda de dicho fichero se efecta solamente en el directorio estndar para los ficheros
con extensin.h (directono include).
Sentencia if
Las sentencias especifican y controlan el flujo de ejecucin del programa. Si no existen
el
En C++ el concepto de bloque de sentencias se utiliza para agrupar un conjunto de
sentencias dentro de un ambito concreto dentro del programa. Un bloque de sentencias es
un conjunto de instrucciones englobadas bajo llaves
{}
.
Sentencia if
La sentencia
if
Elige entre varias alternativas
Sintaxis:
booleanas.

if
(<e
<
>
else
<
>
La sentencia else es opcional, puede utilizarse o no. En el ca
WHILE:
El objetivo de un while es tambin un bucle de cdigo; el bucle while funciona repitiendo su
objetivo mientras la expresin sea cierta. Cuando sta es falsa, el bucle se detiene.
while (expresin) sentencia;
El valor de la expresin se comprueba al principio del bucle, esto significa que, si la expresin
es falsa al iniciarse, el bucle no se ejecutar ni una sola vez.
#include<stdio.h>
#include<conio.h>
main()
{
char c;
c= getch();
while (c!= `q'){ c= getch();
(
);}
}
Ej: Programa que traduce los caracteres que se escriban a un formato codificado; anadiendo
un 1 a cada letra. El programa se detiene cuando se pulsa intro.
#include<stdio.h>
#include<conio.h>
main()
{
char c;
(I
: \ );
c= getch();
while (c!= `\n'){
(% +1);
c= getch();
}
}
DO WHILE:
El bucle do repite la/s sentencia/s mientras la expresin es verdadera, se detiene cuando la
expresin se convierte en falsa. El bucle do es nico, ya que siempre ejecuta el cdigo de
dentro del bucle al menos una vez dado que la expresin que controla el bucle se
comprueba al final del mismo.
do{ sentencias; }while (expresin);
Ej: Pide al usuaro qu quiere hacer con dos nmeros.

#include<stdio.h>
#include<conio.h>
main()
{
int a, b;
char c;
(\n\nQuiere\ );
(S
R
M
r o Dividir\ );
do{
(I
z
: \ );
c=getch();
(\ );
}while (c!= `S' && c!= `R' && c!= `M' && c!= `D');
(I
z
: \ );
(% & );
(I
z
: \ );
(% &b);
if (c== `S'){
(% + );
else
if (c== `R')
(% -b);
else
if(c== `M')
(% * )
else
if(c== `D')
(% / );
}
}
El bucle do es especialmente til cuando el programa que est esperando a que ocurra un
suceso.
CREACIN DE BUCLES ANIDADOS

Cuando el cuerpo de un bucle contiene otro, se dice que el segundo est anidado en el
primero. Cualquiera de los bucles de C puede estar anidado dentro de cualquier otro bucle.
En C, el estndar ANSI especifica que los bucles pueden estar anidados hasta 15 niveles.
Ej:Imprime en pantalla los nmeros del 1 al 10.
for(i=0;i<10;i++){
for(j=1; j<10; j++){
(% );
}
}
Utiliza for para imprimir el alfabeto 3 veces, y cada vez las letras 2 veces.
#include<stdio.h>
#include<conio.h>
main()
{
int i, j, k;
for(i=0; i<3;i++){
for(j=0; j<26;i++){
for(k=0; k<2;i++){
(% \'+j);
}
}
}
}
UTILIZACIN DE BREAK PARA SALIR DE UN BUCLE
Permite Salir de un bucle desde cualquier puntode su cuerpo, pasando por alto su espresin
de finalizacin normal. Cuando break se encuentra dentro de un bucle, el bcle termina
inmediatamente y el control del progranama continua en la sentencia que continua al bucle.
Programa que imprima del 1 al 100 pero cuando llegue al 10 salte.
#include<stdio.h>
#include<conio.h>
main()
{
int i;
for(1=1;i<100;i++){
(% );
if(i==10){
break;
}
}
}
La sentencia breaK se utiliza en bucles en los que una condicin especial puede causar una
terminacin inmediata.
Todos los numeros mltiplos de 6
#include<stdio.h>

#include<conio.h>
main()
{
char c;
int i;
for(i=1;i<10000;i++){
if(!=(i%6)){
(%
? (S/N) );
c=getch();
if(c= `N'){ break;
(\ );
}
}
}
}
SWITCH:
Es una sentencia de seleccin mltiple de C. Se utiliza para elegir un camino entre varios
caminos alternativos de la ejecucin del programa y funciona asi: se compara una variable
con una lista de constantes enteras o de carcter, cuando concuerda con alguna se ejecuta la
secuencia de sentencias asociadas con esa constante.
switch (variable){
case 1:
secuencia de sentencias;
break;
case n:
break;
default:
break;
}
Donde la secuencia de sentencias de default se ejecutan si no coincide con ninguna de las
otras. Default es opcional. Si no hay coincidencias y no existe el default, no se lleva a cabo
ninguna opcin.
Cuando se encuentra alguna coincidencia, se ejecutan las sentencias asociadas con el `case'
hasta que se encuentra con un `break', o en el caso de default o en el ltimo case, hasta que
se alcance el final del switch.
Programa que recorre los numeros 1, 2, 3 y 4 e imprime el nombre del que se ha
introducido:
#include<stdio.h>
main()
{

int i;
(I
1 4: \ );
(% & );
switch(1){
1:
(
);
break;
2:
( );
break;
3:
(
);
break;
4:
(
);
break;
default
(
);
break;
}
}
La sentencia `switch' se diferencia de `if' en que `switch' solamente puede verificar la
igualdad, mientras que el `if', puede ser de cualquier tio, a dems, `switch' slo funcionar
con tipos int y char. Las secuencias de sentencias asociadas con cada case no son bloques,
por lo tanto, no van encerrados entre llaves. El estndar ANSI estable que se permiten, por
lo menos, 257 sentencias case. No puede haber dos constantes case con valores idnticos en
el mismo switch. Es posible tener un switch como parte de una secuencia de sentencias de
otro switch ms externo, esto se llama switch anidado. Si las constantes case del switch ms
externo y ms interno contienen valores comunes, no surgir error.
La sentencia switch se utiliza a menudo para procesar rdenes de men.
#include<stdio.h>
#include<conio.h>
main()
{
int a, b;
char c;
(\n\nQuiere\nSumar, Restar, Multiplicar, Dividir?\ );
do{
(I
z
: );
c=getch();
(\ );
}while ((c!= `S')&&(c!= `R')&&(c!= `M')&&(c!='D'))
(I
z
: );
(% & );
(I
z
: );
(% & );
switch (c){
S:
(% + );
break;
R:
(% -b);
break;

M:
(% * );
break;
case D: if(b!=0){
(% / );
break;}
}
}
La sentencia `break' es opcional. Cuando no existe, la ejecucin pasa al siguiente `case' y
solo se detiene cuando encuentra una sentencia `break' o el final del switch. La sentencia de
secuencias asociada a `case' puede estar vaca, esto permite que dos o mas `case' compartan
una secuencia de sentencias comn sin duplicacin de cdigo.
#include<stdio.h>
#include<conio.h>
main()
{
char c;
(I
: );
c=getch();
switch (c){
case a:
case e:
case i:
case o:
case u:
(
\ );
break;
default:
(E
);
}
}
SENTENCIA FOR
Si necesitamos repetir un grupo de acciones un nmero conocido de veces la mejor
opcin es la sentencia repetitiva for().
for() es una de las sentencias repetitivas ms usadas en los lenguajes de
programacin, esta sentencia inicializa una variable, evala una condicin y luego
realiza una operacin sobre una variable.
Modo de uso:
for(inicializacin;condicin;operacion)
{

//Acciones
}
Secuencia:
1. Se inicializa la variable.
2. Se evala la condicin.
3. Si la condicin se cumple, se realizan las acciones especificadas, si no se
cumple, no se ejecuta ninguna accin y se salta a la prxima lnea.
4. Se realiza una operacin sobre una variable (incremento, decremento).
5. Se repiten los pasos 2, 3 y 4 mientras se cumpla la condicin.
Ejemplos:
Escriba un programa en lenguaje C que solicite el ingreso de dos nmeros (valor
inicial y un valor final) y que muestre por pantalla los nmeros que pertenecen al
intervalo dado.
Solucin:
#include <stdio.h>
void main()
{
//Declaracin de variables
int inicial, final, i;
//Solicitando y leyendo el ingreso de datos desde el teclado
printf("Ingrese el valor inicial: ");
scanf("%d",&inicial);
printf("Ingrese el valor final: ");
scanf("%d",&final);
for(i=inicial;i<=final;i++)
{
printf("%d\n",i); //mostrando por pantalla los nmeros desde
//el valor inicial hasta el valor final
}
}
Contador:
Un contador es una variable cuyo valor se incrementa o decrementa en una cantidad
constante cada vez que se produce un determinado suceso o accin. Los
contadores se utilizan con la finalidad de contar sucesos o acciones internas de un
bucle; deben realizar una operacin de inicializacin y posteriormente las sucesivas
de incremento o decremento del mismo. La inicializacin consiste en asignarle al
contador un valor inicial. Se situar antes y fuera del bucle.
estructura:
int cont = 0
inicio del bucle
i = i +1
fin del bucle
Acumulador:
Es una variable que suma sobre s misma un conjunto de valores para de esta
manera tener la suma de todos ellos en una sola variable. La diferencia entre un
contador y un acumulador es que mientras el primero va aumentando de uno en
uno, el acumulador va aumentando en una cantidad variable.
FUNCIONES C++
Una funcin es un mdulo de un programa separado del cuerpo principal, que
realiza una tarea especfica y que puede regresar un valor a la parte principal del
programa u otra funcin o procedimiento que la invoque.
La forma general de una funcin es:
Tipodato Nomfun(parametros)
{
cuerpo de instrucciones;
return [dato,var,expresion];
}
Donde tipodato especifica el tipo de dato que regresara la funcin.
La instruccin RETURN es quien regresa un y solo un dato a la parte del programa

que la este llamando o invocando, sin embargo es de considerar que return puede
regresar un dato, una variable o una expresin algebraica(no ecuacin o formula)
como lo muestran los siguientes ejemplos;

a) return 3.1416;
b) return area;
c) return x + 15/2;
La lista de parametros formales es una lista de variables separadas por comas (,)
que almacenaran los valores que reciba la funcion, estas variables actuan como
locales dentro del cuerpo de la funcion.
Aunque no se ocupen parametros los parntesis son requeridos.
Vectores, Matrices y Punteros en c++

VECTORES
Un vector, tambin llamado array(arreglo) unidimensional, es una estructura de datos que
permite agrupar elementos del mismo tipo y almacenarlos en un solo bloque de memoria
juntos, uno despues de otro. A este grupo de elementos se les identifica por un mismo
nombre y la posicin en la que se encuentran. La primera posicin del array es la posicin 0.
Podramos agrupar en un array una serie de elementos de tipo enteros, flotantes,
caracteres, objetos, etc.
Crear un vector en C++ es sencillo, seguimos la siguiente sintaxix:

Tipo nombre[tamanyo];
Ejm:
int a[5]; // Vector de 5 enteros
float b[5]; // vector de 5 flotantes
Producto product[5]; // vector de 5 objetos de tipo Producto
Podramos tambin inicializar el vector en la declaracin:
int a[] = {5, 15, 20, 25, 30};
float b[] = {10.5, 20.5, 30.5, 12.5, 50.5}
Producto product[] = {celular, calculadora, camara, ipod, usb}
Como hay 5 elementos en cada array, automticamente se le asignar 5 espacios de
memoria a cada vector, pero si trato de crear el vector de la forma int a[] , el compilador
mostrar un error, porque no indiqu el tamao del vector ni tampoco inicializ sus
elementos.
Asigno valores a los elementos de un vector indicando su posicin:
int a[4] = 30; // le asigno el valor 30 a la posicin 4 del vector.
product[2].setPrecio(300) // le asigno un precio de 300 al producto en la posicin 2.

Obviamente el mtodo setPrecio() debe de estar implementado. Para llenar, recorrer e
imprimir un vector podemos utilizar un bucle for:
#include <iostream>
using namespace std;
int main()
{
int dim;
cout << "Ingresa la dimension del vector" << endl;
cin >> dim; // Supongamos que ingrese 10
int vector[dim]; // mi vector es de tamanyo 10
for(int i = 0; i < dim; i++){
vector[i] = i * 10;
cout << vector[i] << endl;
}
return 0;
}
La salida del programa mostrar: 0 10 20 30 40 50 60 70 80 90 Fcil verdad? Bien ahora
creen 2 o ms vectores y empiecen a hacer funciones bsicas como sumar, restar, buscar,
ordenar, moda, etc que ayudan mucho a ir desarrollando la lgica. No vale copiar y pegar,
mejor es practicar, practicar y practicar.
Aqu una funcin simple para sumar 2 vectores a y b y poner el resultado en un tercer vector
c:
#include <iostream>
void sumar(int a[], int b[], int c[],int dim) {
for (int i = 0; i < dim; i++) {
c[i] = a[i] + b[i];
}
}
void imprimir(int v[], int dim)
{
for(int i = 0; i < dim; i++) {
cout << v[i] << endl;
}
cout << endl << endl;
}
int main()
{
int dim;
cout << "Ingresa la dimensin" << endl;
cin >> dim;
int a[dim];

int b[dim];
int c[dim];
for(int i = 0; i < dim; i++) {
a[i] = i * 10;
b[i] = i * 5;
}
cout << "Vector A " << endl;
imprimir(a, dim);
cout << "Vector B " << endl;
imprimir(b, dim);
sumar(a, b, c, dim);
cout << "Vector C " << endl;
imprimir(c, dim);
return 0;
}
Si ingreso una dimensin de 10, este programa me dara:
Vector A
0 10 20 30 40 50 60 70 80 90
VECTOR B
0 5 10 15 20 25 30 35 40 45
VECTOR C
0 15 30 45 60 75 90 105 120 135
Entonces para tomar en cuenta:
Todo vector debe tener definido un tipo de dato.
Todo vector necesita de una dimensin o tamanyo.
El cdigo de arriba se puede mejorar muchsimo con objetos y clases, este es solo un
pequeo ejemplo.
MATRICES
Una matriz es un vector de vectores o un tambin llamado array bidimensional. La manera
de declarar una matriz es C++ es similar a un vector:
int matrix[rows][cols];
int es el tipo de dato, matrix es el nombre del todo el conjunto de datos y debo de
especificar el numero de filas y columnas.
Las matrices tambin pueden ser de distintos tipos de datos como char, float, double, etc.
Las matrices en C++ se almacenan al igual que los vectores en posiciones consecutivas de
memoria.

Usualmente uno se hace la idea que una matriz es como un tablero, pero internamente el
manejo es como su definicin lo indica, un vector de vectores, es decir, los vectores estn
uno detrs de los otros juntos.
La forma de acceder a los elementos de la matriz es utilizando su nombre e indicando los 2
Subndices que van en los corchetes.
Si coloco int matriz[2][3] = 10; estoy asignando al cuarto elemento de la tercera fila el valor
10.
No olvidar que tanto filas como columnas se enumeran a partir de 0. Bueno y para recorrer
una matriz podemos usar igualmente un bucle. En este caso usando 2 for:
for(int i = 0; i < rows; i++) {
for(int j = 0; j < cols; j++) {
matrix[i][j] = i % j;
}
}
PUNTEROS
El valor de todas las varales que manejamos en nuestros programas se almacenan en
memoria y tienen una direccin. Un puntero es una variable especial que apunta a la
direccin de memoria de una variable.
El puntero tiene a su vez su propia direccin. Todas estas direcciones tienen un formato
hexadecimal.
Los punteros son herramientas muy poderosas con muchas utilidades y enormes ventajas
como veremos ms adelante. A grandes rasgos, un puntero me permite desplazarme en la
memoria, apuntar, re direccionar a ciertas variables, funciones, mtodos, objetos, etc sin
necesidad de mover grandes bloques de datos, lo cual nos ahorra muchsimo el consumo de
memoria en los programas.
Un puntero se debe declarar de acuerdo al tipo de dato al que apunta. Ejem:
int *var; // un puntero que puede apuntar a cualquier variable de tipo entero.
char *u; // puntero de tipo char
Persona *per; // puntero de tipo persona
Para determinar, asignar la direccin de una variable en c++, se usa el operador & y para
obtener el contenido de un puntero utilizamos el operador * Ejem:
int a; // entero
int *b; // puntero a entero
a = 20; // a tiene 20
b = &a; // asigno la direccin de a al puntero b
cout << b << endl; // imprime la direccin de memoria de a;
cout << *b; // imprime 20, osea el contenido de a
Ahora analicemos las siguientes instrucciones y veamos como las variables van cambiando
de valor en tiempo de ejecucin:
#include <iostream>
int main()
{

int a;
int b;
cout << "Ingresa el valor de a: ";
cin >> a;
cout << endl;
cout << "Ingresa el valor de b: ";
cin >> b;
cout << endl;
// Punteros de tipo entero
int *p;
int *p2;
cout << "Antes" << endl;
cout << "Variable a = " << a << endl;
cout << "Direccion de a = " << &a << endl << endl;
cout << "Variable b = " << b << endl;
cout << "Direccion de b = " << &b << endl << endl;
// Tiene basura al principio, podria inicializar con *p=0
cout << "Contenido de p (Basura)= " << *p << endl;
cout << "Direccion de p = " << &p << endl << endl;
cout << "Despues" << endl;
a++;
p= &a;
cout << "Contenido de p = " << *p << endl;
// p ahora tiene la direccin de b
p = &b;
// Le sumo 20 al contenido de p, es decir, estoy incrementando el valor de b
*p +=20;
cout << "Variable a = " << a << endl;
cout << "Variable b = " << b << endl << endl;
// p ahora tiene la direccin de a
p=&a;
// Contenido de p es igual al contenido de a * 5
*p = a * 5;
cout << "Contenido de p = " << *p << endl;
cout << "Variable a = " << a << endl << endl;
// Tiene basura al principio, podria inicializar con *p2=0

cout << "Contenido de p2 (Basura) = " << *p2 << endl;
cout << "Direccion de p2 = " << &p2 << endl << endl;
// El contenido de p es asignado al contenido de p2
p2 = p;
// Incremento 15 al contenido de p2
*p2 += 15;
cout << "Contenido de p2 = " << *p2 << endl;
// p apunta a otra direccin de memoria,se desplaza 4 bytes en memoria
p++;
// El contenido de esa nueva direccin
cout << "Contenido de p (Basura) = " << *p << endl;
return 0;
}
La salida del programa:
ANTES
Variable a = 10
Direccion de a = 0x22ff74
Variable b = 2
Direccion de b = 0x22ff70
Contenido de p (BASURA) = -1017291943
Direccion de p = 0x22ff6c
DESPUES
Contenido de p = 11
Variable a = 11
Variable b = 40
Contenido de p = 55
Variable a = 55
Contenido de p2 (BASURA) = 2293680
Direccion de p2 = 0x22ff68
Contenido de p2 = 70
Contenido de p (BASURA) = 2293680
El contenido de p y p2 al principio es basura porque no tienen ningun valor asignado aun.
Podriamos asignar el valor NULL a un puntero para luego posteriormente en algun problema
que se me presente saber el estado del puntero y saber si contiene algo o no, as:
int *p = NULL;
ARITMTICA DE PUNTEROS
En las ltimas sentencias del programa anterior: p++; cout << *p pueden visualizar que
estoy incrementando el puntero p en 1. Esto quiere decir que el puntero se desplazara 4
bytes en memoria (en este caso por ser entero) y entonces apuntar a otra direccin.

Por eso es que el nuevo contenido de p es basura o bueno el contenido de lo que tiene esa
nueva direccin a la que apunta. Supongamos que definimos un entero y puntero de tipo
char:
char c;
char *d;
d= &c; // asigno la direccion de c a d
c = 'u'; // asigno el valor u a mi variable c
c--; // desplazo una posicion a c
cout << *d;
N I

z
1 y (
1 byte). Es decir, que si d estaba apuntado a una direccin como por ejemplo 0x22ff99,
despues del c estar apuntando a algo como 0x22ff98
Para tomar en cuenta, cosas que no puedo hacer con punteros:
int a = 15;
int *p;
double *q;
void *r;
// No puedo hacer lo siguiente:
p = a; // estoy asignando una variable a un puntero y un puntero es una direccin.
p = &50; // 50 es un valor constante y no una variable, por lo tanto no tiene direccin.
p = &(a+1); // una expresin no tiene direccin.
p = 30; // igual que el primer error, 30 es un entero.
&a = p; // no puedo cambiar la direccin de una variable.
p = q; // p es puntero de tipo entero y q de tipo double.
Un puntero de tipo void, es un puntero al cual le podemos asignar cualquier tipo de puntero.
Por lo tanto si podriamos hacer esto: r = p;
VECTORES Y PUNTEROS
Cuando declaramos un vector int v[10] el nombre del vector, o sea v, es un puntero al primer
elemento del vector, es decir a v[0].
Entonces como un vector es un puntero al primer elemento del mismo, tambin podramos
hacer aritmtica de punteros con el vector.
(v + 1) ; // apunta a v[1];
*(v + 5); // me refiero al contenido de v[5]
// Y tambin puede colocar ndices a los punteros:
int *p; // puntero de tipo entero
p = &v[0]; // p apunta a la direccin del vector v[0] o tambin a v. p = v
p[8] = 80; // le asigno el valor 80 al puntero en la posicion 8, es decir a v[8]
VECTORES DINMICOS
Un vector podra tener una cantidad variable de datos, a este se le llama un vector dinmico.
Para usar vectores dinmicos necesitamos gestionar memoria dinmica. Si bien es cierto que
es trae enormes ventajas, el hacer un mal uso de la memoria dinmica nos podra traer
problemas desastrosos.
Por eso es importante que cuando creemos vectores dinmicos tambin liberemos la
memoria utilizada. Obviamente eliminaremos la memoria utilizada cuando ya no
necesitamos ms usar, en este caso, un determinado vector.
El operador new sirve para reservar memoria dinmica. El operador delete se usa para
liberar la memoria dinmica reservada con new.
Para liberar memoria de un array dinmico usamos delete[] El espacio de memoria que
hemos reservado con new tendr vida hasta que finalice la ejecucin del programa o cuando
liberemos ese espacio con delete.
Siempre es recomendable liberar memoria para posteriormente no tener problemas con
excesivo consumo de memoria.
Un simple ejemplo:
#include <iostream>
int main()
{
int *pv;
int dim;
cout << "Ingresa el tamanyo del vector" << endl;
cin >> dim;
pv = new int[dim];
for(int i = 0; i < dim; i++){
pv[i] = i * i;
cout << pv[i] << endl;
}
delete[] pv;
return 0;
}
MATRICES Y PUNTEROS
Supongamos que declaro una matriz int m[5][5] Como dijimos anteriormente, el nombre o
identificador de un vector es un puntero al primer elemento del vector.
En el caso de matrices el nombre de la matriz, en este ejemplo v, es un puntero que apunta
al primer elemento del primer vector de la matriz.
Entonces m es un doble puntero.m es igual a &m[0] que es igual a la direccion de &m[0][0].

Si declaramos un puntero int *pm y luego igualamos pm = m, p ahora puede desplazarse por
los valores de m. *p; // contenido de m[0], el cual apunta al primer elemento de ese vector,
es decir, m[0][0]
Tambin puedo referirme a los contenidos con aritmtica de punteros:
/* desplazo una posicin a p, se refiere al contenido de m[1],
el cual apunta al primer elemento de ese vector, es decir, m[1][0] */
*(p + 1);
/* desplazo una posicin en el vector principal y este a su vez se desplaza una
posicin en ese vector,
es decir, me refiero al contenido de m[1][1];*/
*(*(p + 1) + 1);
p[2][4] = 20; // asigno el valor 20 a la posicin 2,4 de la matriz
*(*(p + 2) + 4) = 20 // es lo mismo que la asignacin anterior
*(pm[2] + 4) = 20 // tambin lo mismo
// En conclusin:
p[i][j] = *(*(p + i) + j) = *(pm[i] + j)
MATRICES DINMICAS
Para crear una matriz dinmica debemos de crear un doble puntero int **pm y samos al
igual que los vectores el operador new para reservar memoria y delete para liberar. Primero
tenemos que crear el vector que contendr a otros vectores especificando el numero de
vectores que tendra este vector principal. Ejem:
pm = new int* [rows]; // creo el vector de punteros principal

for(int i = 0; i < rows; i++) {
pm[i] = new int[cols]; // para crear los vectores dentro del vector principal
}
Un simple programa que crea una matriz dinmica, asigna valores, muestra el contenido de
cada uno de los elementos los elementos as como sus direcciones de memoria.
Tambin mostramos la matriz usando aritmtica de punteros:
#include <iostream>
int main()
{
// Puntero a una matriz
int **pm;
int cols;
int rows;
cout << "Ingresa nro de filas: ";
cin >> rows;

cout << endl;
cout << "Ingresa nro de columnas: ";
cin >> cols;
pm = new int* [rows];
for (int i = 0; i < rows; i++) {
pm[i] = new int[cols];
}
cout << "Elementos de la Matriz con sus direcciones: " << endl;
for (int j = 0; j < cols; j++) {
pm[i][j] = i + j;
cout << pm[i][j] << "--> ";
cout << &pm[i][j] << endl;
}
cout << endl;
}
cout << endl;
cout << "Elementos de la Matriz con sus direcciones, con aritmtica de punteros: "
<< endl;
for (int j = 0; j < cols; j++) {
// Aritmtica de punteros
*(*(pm + i) + j) = i + j;
cout << *(*(pm + i) + j) << "--> ";
cout << &pm[i][j] << endl;
}
cout << endl;
} // Elimino cada vector de la matriz
delete[] pm[i];
}
// Elimino el vector principal
delete[] pm;
return 0;<!--EndFragment--}
ELEMENTO 2 EJERCICIOS C++

SENTENCIA IF
Programa N.-1 . - Disee un programa que me permita ingresar 3 nmeros

enteros desde teclado que corresponden a 3 notas las mismas que deben estar
entre 1 y 10, obtenga el promedio correspondiente y determine su
equivalencia.
> Si el promedio es mayor o igual a 7, est aprobado.
> Si el promedio es mayor o igual a 5 y Menor que 7 esta suspenso

> Si el promedio es menor que 5 esta reprobado
Anlisis:
Este programa nos sirve para obtener el promedio de un estudiante ya que cuando
ingresemos las tres notas de un alumno nos pueda sacar la suma y el promedio
donde si el promedio es mayor igual que 7 aprueba y si el promedio es mayor o
igual a 5 y Menor que 7 est en suspenso y si el promedio es menor que 5
reprobado.
CODIFICADO:
Las libreras sirven

para llamar a las
funciones que se
desea
Sirve para declarar

las variables
Es el inicio de la
ejecucin
programa
Es
para
#include <stdio.h>
#include <conio.h>
int a,b,c,s,p;
void main()
del
abrir
el
programa
Limpia la pantalla
Es para la ubicacin
clrscr();
gotoxy(35,4);
de las filas y las
columnaslos valores o
Imprime
printf(">>>PROMEDIO<<<") ;
expresiones que se le
da
gotoxy(10,8);printf("Ingrese 1 notas: ");
Lee el dato que se le

da
scanf("%d",&a);

gotoxy(10,10);printf("Ingrese 2 notas: "); scanf("%d",&b);
gotoxy(10,12);printf("Ingrese 3 notas: "); scanf("%d",&c);
Hace el proceso
para
sacar
s=a+b+c;
la
suma de las notas
Es
el
para
proceso
sacar
el
p=s/3;
promedio de las
Limpia la pantalla
Es una condicin donde se
ejecuta
solamente
si
la
if (p>=7 && p<=10)
expresin es verdadera.
{
gotoxy(15,15);printf("APUEBA");
}
Es una condicin que se
formula
dentro
de
la
Else

ejecuta solamente
si la
if(p>=5 && p<=6
{
gotoxy(15,15);printf("SUSPENSO");
}
else
{
if(p>=1 && p<=4)
{
gotoxy(15,15);printf("PIERDE");
} }}
Espera a que se presione

cualquier otra tecla para
finalizar
Ciera
getch();
el
programa
CORRIDO:
PROGRAMA N.-2.- Disee un programa que me permita ingresar un nmero

entero desde teclado desde 1 al 7 y que determine o visualice el nombre del da
de la semana que corresponda
ANALISIS:
En este programa nos sirve para que pueda sacar los das de la semana donde la
condicin es que ingresemos un numero entero del 1 al 7 y que el nmero que
digitemos nos debe salir el da que corresponda.
CODIFICADO:
Las
libreras
para
llamar
funciones
sirven
a
las
que
se
#include<stdio.h>
#include<conio.h>
desea
Funciones estndar
#include<stdlib.h>
Se mostrarn los 4
void borde()
bordes
Es
para
abrir
el
programa
Sirve
declarar
para
Limpia la pantalla
Indica las veces debe

repetirse
int i;
las
clrscr();
for(i=1;i<=80;i++)
una
condicin
{
Para la ubicacin de las
gotoxy(i,3);printf("*");
gotoxy(i,20);
filas y las columnas
Imprime los valores
printf("*");
o expresiones que se
le da
}
for(i=1;i<=24;i++)
{
gotoxy(5,i);printf("*");
}
}
Sirve
declarar
para
las
Es el inicio de la
ejecucin
int a;
main ()
del
{

clrscr();
Llama al borde
borde();
gotoxy(35,5);printf("DIAS DE LA SEMANA");
Es para que cumpla una
condicin y tiene retorno
do
{
gotoxy(29,5);printf(" ");
gotoxy(15,7);printf("Ingrese un numero: ");
scanf("%d",&a);
}
Este es mientas cumpla
while(a<1 || a>7);
la condicin
Es el que te permite
switch(a)
elegir ms de dos vas de

{
Es evaluar varias condiciones y
case 1:
devolver un valor nico para

cada condicin.
gotoxy(35,10);printf("LUNES");
Al final de las acciones
break;
case 2:
gotoxy(35,10);printf("MARTES");
break;
case 3:

gotoxy(35,10);printf("MIERCOLES");
break;
case 4:
gotoxy(35,10);printf("JUEVES");
break;
Impresin de
case 5:
datos
gotoxy(35,10);printf("VIERNES");
break;
case 6:
gotoxy(35,10);printf("SABADO");
break;
case 7:
gotoxy(35,10);printf("DOMINGO");
break;
}
finalizar
getch();
Cierra el programa
Corrido:
PROGRAMA N.-3.- Disee un

programa que me permita
obtener las comisiones de
ventas de la empresa XYZ, Bajo
los siguientes
condicionamientos si el valor de
la venta es igual a
>= 3000 y <=5000 el porcentaje es
de 5%,
>=5000 y <=8500 el porcentaje es de 7%;
>=8500 y <=10000 el porcentaje es de 8%;
>10000 el porcentaje es de 10%;
Visualice el valor total de ventas ingresadas y el total de comisiones entregadas el
proceso se repite n veces.
ANALISIS:
En este programa es el que nos ayuda a obtener las comisiones que una empresa
tiene de las ventas que ha realizado en donde podemos sacar lo siguiente si >=
3000 y <=5000 el porcentaje es de 5%, >=5000 y <=8500 el porcentaje es de 7%;
>=8500 y <=10000 el porcentaje es de 8%; >10000 el porcentaje es de 10%; ya que
tambin este programa me da la opcin donde puedo realizar el proceso las veces
que el usuario lo desea
CODIFICACION:
Las libreras sirven para

llamar a las funciones
que se desea
#include<stdio.h>

#include<conio.h>
Manejo de cadenas
Es
el
inicio
de
#include<string.h>
la
main()
ejecucin del programa
Es
para
abrir
el
programa
int tv, c, totv=0, totc=0;
Sirve para declarar las

variables
Es el que realiza una
char aux='s';
declaracin
while (aux=='s')
la condicin
{
Limpia la pantalla
Es para la ubicacin
de las filas y las
Imprime los valores o
clrscr();
gotoxy(32,2);
printf("EMPRESA DE VENTAS XYZ");
gotoxy(5,5);printf("INGRESE EL TOTAL DE LAS VENTAS: ");
scanf("%d",&tv);
da
ejecuta
solamente
si
la

if(tv>=3000 && tv<=5000)
{
Es un proceso donde va
contando el total de las
c=tv*0.05;
Es una condicin que se

formula
dentro
de
la
else
{
if(tv>5000 && tv<=8500)
{
c=tv*0.07;
}
else
{
if(tv>8500 && tv<=10000)
SENTENCIAS
{
CONDICIONANTES
c=tv*0.08;
}
else
{
if(tv>10000)
{
c=tv*0.10;
}}}}
Este realiza un proceso de ir
totv=totv+tv;
sumando el total de las

ventas ms el total de la
totc=totc+c;
gotoxy(5,7);printf("TOTAL DE LAS COMISIONES ENTREGADAS:

%d",c);
gotoxy(5,10);printf("TOTAL DE LA VENTA: %d",totv);
gotoxy(5,12);printf("TOTAL DE LAS COMISIONES: %d",totc);
gotoxy(2,15);printf("DESEA INGRESAR UNA NUEVA VENTA s/n:
");scanf("%s",&aux);
}
finalizar
Cierra
el
getch();
return 0;
programa
CORRIDO:
PROGRAMA N.-4.- Disee un programa que me permita ingresar 2 nmeros por

teclado y realizar la suma de los mismos.

ANALISIS:
Este programa nos sirve para poder sacar la suma de dos nmeros cualquiera
donde el usuario puede ingresar por teclado los numero que desea para que la
computadora realice el proceso para poder sacar el resultado de la suma
CODIFICACION:
Las
libreras
para
llamar
sirven
a
las
#include<stdio.h>
#include<conio.h>
funciones que se desea

Manejo de cadenas
Es
el
inicio de
ejecucin
Es
para
la
#include<string.h>
void main()
del
abrir
el
programa
Sirve
para
declarar
las
Limpia la pantalla
Es para la ubicacin
int a, b, suma;
clrscr();
gotoxy(15,3);
de las filas y las

printf("SUMA DE DOS NUMEROS");
gotoxy(36,5);printf("
");
gotoxy(10,5); printf("INGRESE EL PRIMER NUMERO: ");

da
scanf("%d",&a);
}

gotoxy(10,7);printf("INGRESE EL SEGUNDO NUMERO:
");scanf("%d",&b);
suma=a+b;
gotoxy(10,9);printf("LA SUMA ES: %d",suma);

finalizar
Cierra el programa
getch();
CORRIDO:
PROGRMA N.-5 Realice la suma de 2 nmeros siempre que el primer valor este
entre 3 y 23 y el segundo valor este entre 5 y 17.
ANALISIS:
En este programe lo que nos pide es que si el primer nmero que ingresamos pro
teclado tiene que tener una condicin que tiene que estar entre 3 y 23 y el segundo
nmero que ingrese tiene que tener la siguiente condicin que tiene que estar entre
5 y 17 y si ingresamos un numero de las dos condiciones que tenemos nos sale
erros y si ingresamos los nmeros que estn dentro de esa condicin se nos realiza
la suma normal tambin se puede realizar las veces que uno quiera
CODIFICACION:
Las
libreras
para
llamar
sirven
a
las
#include<stdio.h>
#include<conio.h
Manejo de cadenas
Es el inicio de la
#include<string.h>
void main()
ejecucin
Es
para
abrir
el
programa
Sirve
para
declarar
las
int a, b, suma, op;
do
condicin y tiene retorno
Limpia la pantalla
Es para la ubicacin
de las filas y las
clrscr();
gotoxy(15,3);
printf("SUMA DE DOS NUMEROS");
do
{
");
gotoxy(10,5); printf("INGRESE EL PRIMER NUMERO: ");

da
scanf("%d",&a);

}
while(a<3 || a>23);
la condicin
do
{ gotoxy(37,7);printf(" ");
gotoxy(10,7);printf("INGRESE EL SEGUNDO NUMERO: ");
scanf("%d",&b);
}
while(b<5 || b>17);
suma=a+b;
gotoxy(10,9); printf("LA SUMA ES: %d", suma);
gotoxy(10,13);printf("PRESIONES 1 PARA CONTINUAR O 0 PARA
SALIR: ");
scanf("%d",&op);
}

condicin
tiene

finalizar
Cierra el programa
CORRIDO:
while(op==1);
getch();
PROGRAMA N.-6. Disee un programa que me permita ingresar el nombre de

una persona y la edad de la misma que debe estar entre 3 y 85, para obtener
las siguientes equivalencias:
Si la edad est entre 3 y 5 debe visualizarse: nombre, es un beb
Si la edad es > 5 y <13 debe visualizarse: nombre, es un nio
Si la edad es > 13 y 21 debe visualizarse: nombre, es un adolescente
Si la edad es > 21 y 60 debe visualizarse: nombre, es un adulto
Si la edad es > 60 debe visualizarse: nombre, es un adulto mayor
El programa se repite tantas veces como el usuario lo desee.
ANALISIS:
En este programa presentado, tenemos que utilizar una variable op que se utilizara
para la opcin desea continuar SI o NO, esto se lo realiza con el Laso DO WHILE
que permite generar nuevamente el programa. Utilizamos el if para realizar la
condicin y si es la condicin es verdadera me imprima el mensajes que deseo que
me aparezca en el programa.
CODIFICACION:
#include<stdio.h>
Libreras tipos usados por varias operaciones de entrada y salida, es
#include<conio.h>
un comentario
#include<string.h>
main ()
Para iniciar el programa
Abrir el programa
int ed, op;
Definicin de variables: antes de realizar algunas operaciones en
char nom[25];
el programa se debe declarar las variables que se utiliza
do
Cargar o inicializar variable de condicin
{
clrscr();
Borra todo el contenido de la pantalla
Imprime el mensaje
gotoxy(15,2);printf("EQUIVALENCIA DE LAS EDADES");

gotoxy(5,5);printf("INGRESE EL NOMBRE: ");scanf("%s",&nom);
do
{
gotoxy(22,7);printf("INGRESE SU EDAD: ");scanf("%d",&ed);
Es para ingresar los
gotoxy(5,7);printf("INGRESE SU EDAD: ");scanf("%d",&ed);
datos
}
Rompimiento del ciclo
while(ed<3 && ed>85);

if(ed>=3 && ed<=5)
Si la condicin es verdadera, y
comienza a realizar el proceso
{
gotoxy(7,10);printf("ES UN BEBE");
Realiza el proceso
}
else
{
if(ed>5 && ed<=13)
{
gotoxy(7,10);printf("ES UN NINO");
}
else
{
if(ed>13 && ed<=21)
{
gotoxy(7,10);printf("ES ADOLESCENTE");
}
else
{
if(ed>21 && ed<=60)
{
Realiza
el
proceso
del
impresiones de los resultados
programa

gotoxy(7,10);printf("ES ADULTO");
}
else
{
if(ed>60)
{
gotoxy(7,10);printf("ES ADULTO MAYOR");
}
}
}
Cierre de los if
}
}
gotoxy(10,13);printf("PRESIONES 1 PARA CONTINUAR O 0 PARA SALIR:
");scanf("%d",&op);
}
while(op==1);
getch();
}
CORRIDO:
Rompimiento del ciclo

Retorna el carcter ledo desde
teclado
Cierres del programa
PROGRAMA 7. Disee un programa que me permita simular la venta

de productos en una factura, de la cual necesitamos ingresar el
nombre del producto, la cantidad, precio unitario y calcular el precio
total. El programa se repite n veces segn los productos que el usuario
desee ingresar.
ANALISIS:
En este programa realizamos una factura con diseo incluido utilizamos variables
como int, float, char las de tipo float nos sirve para cantidades con decimales y las
char para ingresar el detalle de la factura, utilizamos un for para el diseo de la
estructura del margen de la factura, tambin un lazo DO-WHILE par realizar de
nuevo el programa, y un if para las condiciones respectivas en cada literal,
tenemos variables para almacenar los clculos respectivos.
CODIFICACION:
#include<stdio.h>
Libreras tipos usados por varias operaciones de entrada y salida, es un
#include<conio.h>
compilador
void main()
void=para iniciar el programa
{
Abrir el programa
int i,op;
Para almacenar valores entero
float cant,uni,vt,iva,total,sub;
Para almacenar datos decimales
char det[15],preg[2];
Para almacenar caracteres
clrscr();
Borra todo el contenido de la pantalla
for(i=1;i<=80;i++)
{
}
Diseo de la estructura del margen
for(i=1;i<=24;i++)
{
}
gotoxy(35,2);printf("=============");
gotoxy(35,3);printf("F A C T U R A");
gotoxy(35,4);printf("=============");
gotoxy(15,6);printf("CANT
DETALLE
V.UNIT V.TOTAL");
Diseo de la
gotoxy(14,7);printf("===================================");
portada
gotoxy(43,21);printf(" Subtotal");
gotoxy(43,22);printf(" IVA 12% ");
gotoxy(43,23);printf(" Total");

i=8;
Se ingresa los valores de la fila 8
sub=0;
do
El lazo do while primero realiza la accin y luego pregunta la prueba de condicin es
{
hecha al finalizar el ciclo
gotoxy(15,i); scanf("%f",&cant); Es para ingresar los datos
gotoxy(27,i); scanf("%s",&det);
gotoxy(42,i); scanf("%f",&uni);
vt=cant*uni;
Proceso para realizar el calculo
gotoxy(54,i); printf("%4.2f",vt);
Imprime el valor total
gotoxy(5,23); printf("Desea ingresar otro producto: "); scanf("%s",&preg);
if(preg[0]=='s')
{
Si la condicin es verdadera
op=1;
i=i+1;
Para que sume las filas
}
else
{
Si la condicin es falsa
op=0;
}
sub=sub+vt;
}
Realiza el proceso del programa
while(op==1);
iva=0.12*sub;
total=sub+iva;
gotoxy(54,21); printf("%4.2f",sub);
gotoxy(54,22); printf("%4.2f",iva);
Para imprimir los valores
gotoxy(54,23); printf("%4.2f",total);
getch();
Retorna el carcter ledo desde teclado
}
Se cierra el programa

CORRIDO:
PROGRAMA N.-9 Disee un programa que me permita calcular el promedio

general de las notas de distintas materias correspondientes al 2 Semestre de
Docencia en Informtica, en donde cada una de las notas ingresadas debe estar
entre 1 y 10.
Anlisis:
En este programa deseamos encontrar el promedio general del curso para lo q utilizamos
z DO- WHILE
1
10
#include<conio.h>
Libreras tipos usados por varias operaciones de
#include<stdio.h>
entrada y salida un compilador
void main()
Abrir el programa
{
Inicia el programa
char no[15];
int op,c=0,d;
Definicin de variables: antes de realizar algunas
float n1,n2,n3,fla=6;
operaciones en el programa se debe declarar las
float p,pg=0;
clrscr();
Borra la pantalla
Imprime mensajes y
gotoxy(25,2);printf("Facultad de Ciencias Humanas");
para
la
gotoxy(27,3);printf("Segundo Informtica");
presentacin
del
gotoxy(10,5);printf("Mdulos
Nota1 Nota2 Nota3 Promedio");
Cargar
o
inicializar
do
variable de condicin

{
c=c+1;
flushall();
gotoxy(10,fla);gets(no);
do
{
gotoxy(27,fla);printf(" ");
gotoxy(27,fla);scanf("%f",&n1);
}while(n1>10 || n1<1);
do
{
}while(n2>10 || n2<1);
do
{
}while(n3>10 || n3<1);
p=(n1+n2+n3)/3;
pg=pg+p;
Utiliza un contador
Cargar
inicializar
Ingresa la primera nota
Aqu cierra la condicin
que debe estar entre 1
hasta 10
Cargar o
inicializar
Ingresa la segunda
nota
hasta 10
Ingresa la tercera nota
Realiza el clculo del
promedio
Aqu nos imprime las notas del
gotoxy(54,fla);printf("%2.2f",p);
programa
gotoxy(10,15);printf("%2.2f",pg);
fla=fla+1;
Nos pide la
gotoxy(10,10);printf("Presione 1 para continuar o 0 para salir: ");scanf("%d",&op);
opcion
}while(op==1);
Cierra la condicin
d=pg/c;
Imprime el promedio general
gotoxy(10,16);printf("g%d",d);
getch();
}
teclado
Cierra el programa
CORRIDO:
PROGRAMA N.-9 Realice un programa en C++ que me permita obtener

el lquido a recibir de un empleado bajo los siguientes parmetros:
El empleado percibe un salario mnimo vital el mismo que depende de su categora, existen
3 posibles alternativas, este datos deber ser ingresada al inicio del programa
conjuntamente con el nombre del empleado:
Categora 1
180,00
Categora 2
250,00
Categora 3
380,00
A este salario mnimo vital se le incluye algunos rubros que son:
1. Horas extras, las mimas que no pueden exceder 8, cada hora extra cuesta Usd. 1,80.
2. Bono familiar la misma que est condicionada. Si el empleado tiene ms de dos hijos
se le paga Usd. 4,50 por cada hijo caso contrario se le reconoce Usd. 6,20 por cada
hijo.
3. Obtenga el valor del IESS que es el 11,5 % del nominal

4. Se le descuenta el 2% del nominal como aporte a la asociacin
5. Obtenga los valores correspondientes de ingresos, egresos y total a recibir.
El programa se genera n veces.
ANALISIS:
En este programa que hemos elaborado para sacar el lquido a recibir de un empleado,, tenemos que
z

z
SI NO
z
con el Laso DO WHILE
z

condicionar las horas extras y para escoger la categora del empleado y acumuladores para realizar
clculos
CODIFICACION:
Programa:
/*Obtener el lquido de un empleado*/
Comentarip del programa
#include<conio.h>
Libreras tipos usados por varias operaciones
#include<stdio.h>
de entrada y salida, es un comentario
main()
{
Para abrir el programa
int a,b,horax,bonofo,sue,op=0;
Definicin de variables: antes de realizar algunas
float c,d,iees,aso,ingre,egreso,tot;
operaciones en el programa se debe declarar las
char nom[10];
variables que se utiliza
clrscr();
Borra la pantalla
do
{
gotoxy(27,2);
Impresin de mensaje
printf("++ROL DE PAGOS++");
gotoxy(20,4);
Imprime el mensaje
printf("Ingrese el nombre del empleado: ");
scanf("%s",& nom);
Ingresa datos
gotoxy(27,6);
printf("**Categoria**");
Imprime el mensaje
gotoxy(20,8);
posicionamiento
en donde desee aparecer el
printf("categora 1=180 categora 2= 250 categoraDa
3=380"
);
mensaje
gotoxy(20,10);
printf("Ingrese la Categora que desee: ");
scanf("%d",&a);
gotoxy(20,12);
printf("Ingrese nmero de hijos que tiene: ");
Diseo del programa
scanf("%d",&b);

gotoxy(20,14);
printf("Ingrese las horas extras: ");
scanf("%d",&horax);
if(horax>0 && horax<=8)
{
d=horax*1.80;
}
if(b>0 && b<=2)
{
c=6.20*b;
}
else
c=4.50*b;
if (a==1)
{
iees=0.115*180;
aso=0.02*180;
sue=180;
ingre=sue+c+d;
egreso=aso+iees;
tot=ingre-egreso;
gotoxy(23,15);
printf("INGRESO");
gotoxy(24,16);
printf("*Sueldo= %.d",sue);
gotoxy(24,17);
printf("*Horas Extras= %.2f",d);
gotoxy(24,18);
printf("*Bono Familiar= %.2f",c);
gotoxy(27,19);
printf("TOTAL INGRESOS= %.2f",ingre);
gotoxy(23,20);
printf("EGRESOS");
gotoxy(24,21);
printf("*Aporte al Iess= %.2f",iees);
gotoxy(24,22);
printf("*Aporte Asociacin= %.2f",aso);
gotoxy(27,23);
printf("TOTAL EGRESOS= %.2f",egreso);
gotoxy(29,24);
printf("LIQUIDO A PAGAR= %.2f",tot);
Imprime
los
resultados
obtenidos del programa
Imprime los resultados obtenidos

del programa

}
if (a==2)
{
iees=0.115*250;
aso=0.02*250;
sue=250;
ingre=sue+c+d;
egreso=aso+iees;
tot=ingre-egreso;
gotoxy(23,15);
printf("INGRESO");
gotoxy(24,16);
gotoxy(24,17);
gotoxy(24,18);
gotoxy(27,19);
gotoxy(23,20);
printf("EGRESOS");
gotoxy(24,21);
gotoxy(24,22);
gotoxy(27,23);
gotoxy(29,24);
}
if(a==3)
{
iees=0.115*380;
aso=0.02*380;
sue=380;
ingre=sue+c+d;
egreso=aso+iees;
tot=ingre-egreso;
gotoxy(23,15);
printf("INGRESO");
gotoxy(24,16);
Imprime resultados
Imprime resultados

gotoxy(24,17);
gotoxy(24,18);
gotoxy(27,19);
gotoxy(23,20);
printf("EGRESOS");
gotoxy(24,21);
gotoxy(24,22);
gotoxy(27,23);
gotoxy(29,24);
gotoxy(30,24);
printf("Desea ingresar otro empleado digite 1");
gotoxy(30,25);
printf(" Desea salir del programa digite 0");
gotoxy(30,26);
printf("Ingrese la op= ");scanf("%d",&op);
}
} while (op==1);
getch();
return 0;
Imprime los resultados del programa
Nos imprime el mensaje para escoger

la opcin que deseemos esoger
cicloteclado
Retorna elRompimiento
carcter ledodel
desde
Cierra el programa
CORRIDO:
PROGRAMA N.-10. Disee un programa que me permita imprimir un borde de

pantalla.
ANALISIS:
El progra
z

z
opcin desea continuar SI o NO, esto se lo realiza con el Laso DO WHILE que permite
generar nuevamente el programa. Utilizamos el lazo for para generar el borde en la pantalla.
CODIFICADO:
#include<stdio.h>
libreras
#include<conio.h>
void main ()
Libreras tipos usados por varias operaciones de entrada y salida, es un
comentario
{
Para abrir el programa
int n,fila,i,op=1;
do
Lazo do while inicia la condicin
{
Borra la pantalla
clrscr();
for(i=1;i<=80;i++)
Proceso
{
Imprime el margen
Cierra el for
}
for(i=1;i<=24;i++)
Proceso
{
Imprime el margen
}
Imprime el mensaje
gotoxy(28,5);printf("ingrese el lmite: ");
scanf("%d",&n);
Ingresa datos
fila=6;
Indica el lmite
for(i=2;i<=n;i+=2)
{
Imprime el resultado
gotoxy(20,fila);printf("%d",i);
fila=fila+1;
Utiliza un contador
}
fila=6;
Indica el lmite
for(i=1;i<=n;i+=2)
{
Imprime el resultado
gotoxy(50,fila);printf("%d",i);
fila=fila+1;
}
gotoxy(20,25);printf("desea continuar");
Imprime el mensaje para escoger la opcin
scanf("%d",&op);
}while(op==1);
Finaliza el lado while
getch();
}
Cierra el programa
CORRIDO:
PROGRAMA N.-11.- Disee un programa que me permita imprimir un borde de

pantalla
Anlisis: Este programa nos permite generar un margen o borde en pantalla

para mejorar la presentacin en pantalla.

Codificacin:
Las
libreras
para
llamar
#include<stdio.h>
sirven
a
las
#include<conio.h>

Es
el
inicio de
ejecucin
main()
la
del
{
int i;
Sirve para declarar

las variables
Limpia la pantalla
clrscr();
Inicio de un ciclo
for(i=1;i<=80;i++)
con un lmite
{
Es para la ubicacin
gotoxy(i,1);
de las filas y las

Inicio de un ciclo
printf("*");
con un lmite
for(i=1;i<=24;i++)
{
}

finalizar
getch();
Ciera
el
programa
Corrido:

nmeros pares
Anlisis: este programa nos va a generar el borde en pantalla as como

tambin generara los nmeros pares ingresando un lmite ingresando
desde teclado.
Corrido:
Las
libreras
para
llamar
sirven
a
las
#include<stdio.h>
#include<conio.h>

Es
el
inicio de
ejecucin
la
del
main()
{

int i;
Sirve para declarar

las variables
Limpia la pantalla
clrscr();
Inicio de un ciclo
for(i=1;i<=80;i++)
con un lmite
{
Es para la ubicacin
gotoxy(i,1);
de las filas y las

printf("*");
for(i=1;i<=24;i++)
Inicio de un ciclo
con un lmite
{
}
y(28 3);
g
y(3 5);
( SERIE DE NUMEROS PARES );

(INGRESE EL LIMITE::);
(% &
);
for(i=1;i<=lim;i++)
{
gotoxy(col,11);
Acumulador para que

vaya dando espacios
(%
2);
col=col+4;
Mensaje para continuar o

terminar el programa
y(3 22);
(PRESIONE UNO PARA VOLVER A REPETIR EL
PROCESO O 0 PARA FINALIZAR::);
(% );

}
While(op==1)
Cierre del ciclo while
Finalizacin
del
programa
getch();
}
3.- CORRIDO

nmeros pares y los impares que existen hasta el nmero lmite ingresado desde teclado.
ANALISIS: este programa nos ayuda a generar nmeros pares e impares y a

la vez nos genera el borde.
Codificacin:
#include<conio.h>
Las libreras sirven para

llamar a las funciones
que se desea
#include<stdio.h>

void main()
Es
el
inicio de
ejecucin
la
del
int limite,i,fla,op; clrscr();
Sirve para declarar

las variables
for(i=1;i<=80;i++)
Inicio de un ciclo
de contiene un
}
for(i=1;i<=24;i++)
{
}
gotoxy(25,5);printf("Series");
gotoxy(15,6);
Inicio de un ciclo
de contiene un
Imprime
printf("Ingrese limite: ");
un
mensaje
Lee
datos
scanf("%d",&limite);
ingresa
fla=6;
Igualacin desde
una
cierta
for(i=2;i<=limite;i+=2)
{
gotoxy(20,fla+1);printf("%d",i);
contador

fla=fla+1;
}
fla=7;
for(i=1;i<=limite;i+=2)
{
gotoxy(40,fla);printf("%d",i);
fla=fla+1;
}
Finalizacin
programa
del
getch();
}
3.- CORRIDO
PROGRAMA N.-14.- Disee un programa que me permita generar las

tablas de multiplicar de cualquier factor ingresado desde teclado y por
cualquier limite ingresado desde teclado, el programa se genera n
veces, disee el borde en pantalla.
ANALISIS: este programa genera el borde como tambin genera la tabla de
multiplicar ingresando por teclado el nmero y el lmite.

Codificacin:
#include<conio.h>
#include<stdio.h>
LIBRERIAS
HABILITA
Inicio
de
void main()
un
programa
Declaracin
variables
do
{
clrscr();
Inicio de while nos

ayuda a repetir
varias
veces
de
{
int i,f,l,d,op;
el
programa
for(i=1;i<=80;i++)
{
}
Inicio de un ciclo
con limite
Cierre del ciclo
for(i=1;i<=24;i++)
{
Inicio de un ciclo
de contiene un
Genera ubicacin
}
gotoxy(15,2);printf("Tabla de multiplicar");
gotoxy(10,3);
Imprime mensajes
printf("Factor: ");
Permite
scanf("%d",&f);
ingresar
datos
operaciones
gotoxy(10,4);printf("Limite: ");scanf("%d",&l);
for(i=1;i<=l;i++)
{
d=f*i;
gotoxy(10,4+i);printf("%d",f);
gotoxy(18,4+i);printf("%d",d);
gotoxy(12,4+i);printf("*");
gotoxy(16,4+i);printf("=");
gotoxy(14,4+i);printf("%d",i);
}
gotoxy(15,20);printf("Desea salir 1/0: ");scanf("%d",&op);

}while(op==1);
Cierre
del
ciclo
while
Cierre
del
getch();
}
programa
3.- CORRIDO DEL PROGRAMA
Programa 15
Enunciado:
Disee un programa que me permita visualizar la factorial de un nmero ingresado desde
teclado.
Las libreras sirven para llamar a las funciones que se desea
Codificado
#include<stdio.h>
#include<conio.h>
#include<string.h>
main()
{
Es el inicio de la ejecucin
Es para abrir el programa
int i, fact=1, num, fila=6, op;
Sirve
para
declarar
las
do
Es para que cumpla una condicin y tiene retorno
Es para que cumpla una condicin y tiene retorno
fila=6;
fact=1;
clrscr();
limpia la pantalla
gotoxy(31,2);printf("FACTORIAL DE UN NUMERO");
imprime el titulo
for(i=1;i<=80;i++)
inicializa el for
{
llaves de inicio del for
impression de *
}
finalize el for
for(i=1;i<=24;i++)
inicializa el for
{
llave de inicio del for
imprime *
}
finaliza el ciclo for
gotoxy(3,4);printf("Ingrese un numero: ");scanf("%d",&num); imprime y lee variables
for(i=1;i<=num;i++)
inicia el for hasta num
{
llave de inicio de for
fact=fact*i;
contador
gotoxy(3,fila);printf("Factorial de %d: %d",i,fact);
inpresion de resultados
fila=fila+1;
contador de dila
}
cierra llaves de for
gotoxy(3,23);printf("PRESIONE 1 PARA CALCULAR OTRO FACTORIAL O 0 PARA
FINALIZAR: ");scanf("%d",&op);
}
cierre de do
while(op==1);
reconoce la opcion
getch();
pausa
}
finalisa el programa
1. Corrido del Progrma:
4.-Analisis del Programa:

Este programa nos permite realizar los nmeros factoriales se peuden repetir n veces del
numero que le ingresemos.
Programa 16
1.- Enunciado:
Disee un programa que me permita generar una serie de nmeros, en donde el numerador es
cualquier factor ingresado desde teclado, y el numerador es la serie de los nmeros impares.
2.- Codificado:
#include<stdio.h>
#include<conio.h>
activacin de librerias
#include<string.h>
main()
cabeza del programa
{
llave de inicio de programa
int i, j, np, cont=0, c=10, res, op, col=15, imp=1;
declaracion de variables
do
inicio del ciclo do
{
llave de inicio
imp=1;
inicializo imp en 1
col=15;
columna en 15
c=10;
c en 10

clrscr();
borrado de pantalla
gotoxy(30,3);printf("SERIE PRIMOS/IMPARES");
inpresion del titulo
for(i=1;i<=80;i++)
inicia for
{
impresion de *
}
cierre del ciclo
for(i=1;i<=24;i++)
inico condicion
{
inicio
impresion de*
}
gotoxy(3,5);printf("Limite: ");scanf("%d",&np);
gotoxy(10,7);printf("1");
lectura e impresion de datos
gotoxy(8,6);printf("Serie: ");
for(i=1;i<=np;i++)
condicion del for
{
llave de inicio de for
cont=0;
inicia el contador en 0
for(j=1;j<=i;j++)
condicion del for
{
res=i%j;
proceso
3.- Corrido de programa
4.- Anlisis del Programa:

Este programa lo generamos el numerador se imprimen los nmeros primos y en el
denominador los impares se repetirn las veces que nosotros queramos.
Programa 17
Disee un programa en C++ que me permita generar n nmeros primos, el proceso se repite n
veces y se visualiza el borde de pantalla.
2.- Copdificado
#include<conio.h>
#include<stdio.h>
activacion de librerias
main()
inicio del programa
{
int i=0,j=0,lt,c,res=0,op=1,nc=0;
do
{
clrscr();
for(i=1;i<=24;i++)
{
Inicio del programa e proceso de
impresin del borde en el programa
}
for(i=1;i<=80;i++)
{
}
gotoxy(29,2);printf("NUMEROS PRIMOS");
Impresin de datos
gotoxy(6,4);printf("INGRESE EL LIMITE : ");scanf("%d",&lt);
gotoxy(6,6);printf("1");
c=2;
for(i=2;i<=lt;i++)
{
for(j=1;j<=c;j++)
proceso para calcular los numerous primos
{
if(i%j==0)
{
nc=nc+1;
}
}
cierre de los ciclos for
if(nc==2)
{
printf("%6d",i);
impresion de i

}
cierre
nc=0;
inicia en 0
c=c+1;
aumento de 1
}
gotoxy(2,23),printf("REPETIR 1 Y 0 PARA SALIR : ");scanf("%d",&op)lee e imprime
}
while(op==1);
reconoce la opcin
getch();
pausa
}
finaliza el programa
3.- Corrido de programa
4.-Analisis del Programa:

Este programa genera }un numero primo asta el limite que nostros ingresemos.
Programa 18
Realice un programa que me permita generar la siguiente serie de datos: como numerador la
serie de los impares y como denominador la factorial.
2.-Codificado:
#include<stdio.h>
activacion de librerias
#include<conio.h>
void main()
{
int i,l,a,b,c,op;
inicio del programa y declaracion de variables
float f;
do
{
clrscr();
for(i=1;i<=80;i++)
{
proceso de impresion de borde
}
for(i=1;i<=24;i++)
{

}
gotoxy(35,2);printf("Serie de datos");
gotoxy(15,3);printf("Limite: ");
impresion y lectura de datos
scanf("%d",&l);
a=1;
f=1;
for(i=1;i<=l;i++)
{
f=f*i;
gotoxy(28,5+i);printf("%8.0f ",f);
proceso de calculo de los numeros
gotoxy(15,5+i);printf("%d",a);
a=a+2;
gotoxy(25,5+i);printf("/");
}
gotoxy(15,23);printf("Desea salir 1/0: ");
scanf("%d",&op);
}
while(op==1);
reconose la opcion del while
getch();
}
pausa y finalisacion del programa.
3.-Corrido d eprograma:
Programa 19
Genere n elementos de la siguiente serie: cualquier factor ingresado desde teclado como
numerador, el denominador nmeros pares.
1. Enunciado:
Genere n elementos de la siguiente serie: cualquier factor ingresado desde teclado como
numerador, el denominador nmeros pares.

2. Codificado:
#include<conio.h>
Librerias
#include<stdio.h>
main()
{
int i, lim, nu=0, num=2, col=5, op, fact; inicio del programa y declaracion de
variables
do
{
nu=0;
inicio de variables en 0 y 5
num=2;
col=5;
clrscr();
borrado de pantalla
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("-");
}
impresion del borde en el programa
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("+");
}
gotoxy(30,3);printf("Serie 1 Factor y Numeros pares");
gotoxy(3,5);printf("Limite: ");scanf("%d",&lim);
lectura en impresion de
datos
gotoxy(3,7);printf("Factor: ");scanf("%d",&fact);
nu=fact;
for(i=1;i<=lim;i++)
inicio del for
{
inicio del for
gotoxy(col,9);printf("%d",fact);
fact=fact+nu;
proceso
gotoxy(col,10);printf("--");
gotoxy(col,11);printf("%d",num);lectura e impresion de datos
num=num+2;
acumulador
col=col+4;
contador
}
gotoxy(3,22);printf("Presione 1 para contuniar o 0 para salir
impresin y
");scanf("%d",&op);
lectura
}
fin for
while(op==1);
reconocimiento
getch();
pausa
}
fin del programa
PROGRAMA N.-21. -Disee un programa que me permita generar la

siguiente serie de datos:Las
primos
ensirven
el numerador
libreras
para llamar e impares en el
a las funciones q se desee.
denominador.}
CODIFICADO
#include<conio.h>
#include<stdio.h>
main()
Es el inicio de la ejecucin del
{
int res,j,i,col,lim,op,cont,den;
do
Sirve para declarar variables
Cumple una funcin que tiene retorno
{
den=-1;
cont=0;
Las variables estn declaradas desde el
res=1;
nmero que van a empezar
col=5;
Limpia pantalla

clrscr();
for(i=1;i<=80;i++)
{
gotoxy(i,1); printf("+");
Utilizamos el ciclo for para disear el margen de la
gotoxy(i,24); printf("+");
pantalla en donde sealamos el numero en el que
empieza y hasta que numero va a llegar, ubicamos
for(i=1;i<=24;i++)
coordenadas e imprimimos en este caso asteriscos.
{
gotoxy(1,i); printf("+");
gotoxy(80,i); printf("+");
}
gotoxy(20,3); printf("**SERIE DE NUMEROS PRIMOS**");
gotoxy(10,5); printf("INGRESE LIMITE==>");
scanf("%d",&lim);
for(i=1;i<=lim;i++)
Para ingresar hasta que numero va a llegar
{
for(j=1;j<=i;j++)
{
res=i%j;
if(res==0)
Operacin
para
obtener
el
Indica que el residuo debe ser 0 para que se cumpla la
{
cont=cont+1;
Sirve
para
ir
}
}
if(cont==2)
Indica si es impar o no
{
gotoxy(col,7); printf("%d",i);
Imprime resultado
den=den+2;
Operacin del denominador
gotoxy(col,8); printf("-");
gotoxy(col,9); printf("%d",den);
Imprime lnea
Imprime

col=col+5;
Se suma a col 5 para la posicin
}
gotoxy(10,20); printf("PRESIONE 1 SI DESEA REPETIR EL PROCESO CASI CONTRARIO 0==>");
scanf("%d",&op);
}
Cierra el ciclo do while
while(op==1);
getch();
Espera que presione cualquier
otra tecla para salir
ANALISIS
El primer ciclo lleva la cuenta de los nmeros de 1 a lim de uno por uno en la variable c, luego se
inicia un ciclo de 1 a i en la variable j. Este ciclo se har n veces porque est dentro de el primer
ciclo, en la variable res se guarda el residuo de dividir i / j , si el residuo es cero, se incremento al
contador, si al terminarse el segundo ciclo el contador es igual a 2, significa que el nmero es primo y
lo imprime, y eldenominador solo le va sumando 2 al numero que ingrese el usuario
PROGRAMA N.-22.-disee un programa que me permita generar la

siguiente serie de datos: como numerador los nmeros impares y
como denominador la serie fibonasi.
CODIFICADO:
#include<conio.h>
Las libreras sirven para llamar
#include<stdio.h>
main()
{
int i,lim,col,a,b,c,fibo,op,num
do
{
fibo=0;
a=1;
Declaramos desde que numero van a

empezar las variables

b=0;
col=5;
Declaramos que va a empezar desde la columna 5
num=-1;
Declaramos desde que numero va a empezar la
clrscr();
Limpia
for(i=1;i<=80;i++)
{
gotoxy(i,1); printf("*");
Utilizamos el ciclo for para disear el margen de la
pantalla en donde sealamos el numero en el que
for(i=1;i<=24;i++)
empieza y hasta que numero va a llegar, ubicamos

coordenadas e imprimimos en este caso asteriscos.
{
gotoxy(1,i); printf("*");
}
gotoxy(10,3); printf("**SERIE DE DATOS**");

gotoxy(10,5); printf("INGRESE EL LIMITE==>");
Empezamos
escribir
lo
que
deseamos que aparezca en la
scanf("%d",&lim);
Guarda la variable indicada
for(i=1;i<=lim;i++)
Sealamos hasta el nmero que se va a
Sumamos al nmero que ingrese como num el 2 para obtener nmeros
num=num+2;
gotoxy(col,7); printf("%d",num);
Imprime
el
c=a+b;
a=b;
Relizamos la operacin, indicamos que a=b;
b=c;
que b=c; para que se relize correctamente el
fibo=c;
proceso, y al final decimos que fibo=c
gotoxy(col,9); printf("%d",fibo);
gotoxy(col,8); printf("-");
col=col+5;
Imprime
el
Imprime la lnea que separa al numerador del
Sumamos a col 5 para que vaya cambiando de
}
gotoxy(10,20);
printf("PRESIONE 1 SI DESEA REPETIR EL PROCESO CASO CONTRARIO 0==>");
scanf("%d",&op);

}
while(op==1);
Final
del
ciclo
do
getch();
Espera que se presione cualquier otra tecla
para finalizar
ANALISIS
En este programa se va smando a col el umero 5 para que todos a fraciones esten en su posici{on
correcta adema{as se utiliza un iclo do while para que se repita el proceso tanta veces quiera el
usuario.
CORRIDO
Disee un programa que me presente un men de

opciones con las operaciones bsicas, estas son suma, resta,
multiplicacin, divisin y una opcin para salir del programa.
PROGRAMA N.-23.-
CODIFICACION:
#include<conio.h>
#include<stdio.h>

#include<stdlib.h>
void borde()
Funcin especficamente para el borde
{
int i;
Variable para el margen de pantalla.

for(i=1;i<=80;i++)
Ciclo for para sealar de que numero a que numero va a ir.
{
}
Utilizamos el ciclo for para disear el
for(i=1;i<=24;i++)
margen de la pantalla en donde
sealamos el numero en el que empieza
y hasta que numero va a llegar,
ubicamos coordenadas e imprimimos en
}
}
void main()
{
int i,suma,a,b,resta,multi,op;
float divi;
Variable para trabajar con decimales
do
{
clrscr();

Limpia la pantalla
borde();
Llama al borde sirve para no volver a repetir el proceso

de este. DE OPCIONES***OPERACIONES MATEMATICAS");
gotoxy(25,3); printf("MENU
gotoxy(10,5); printf("1.-SUMA");
gotoxy(10,7); printf("2.-RESTA");
gotoxy(10,9); printf("3.-MULTIPLICACION");
gotoxy(10,11); printf("4.-DIVISION");
gotoxy(10,13); printf("5.-SALIR");
Proceso del
opciones
gotoxy(10,15); printf("QUE OPCION DESEA==>");

scanf("%d",&op);
switch(op)
Variable selectiva sirve para elegir una de las funciones
{
case 1:
Para sealar el primer proceso
clrscr();
Limpia pantalla
borde();
Llama al borde
men
de

gotoxy(10,5); printf("INGRESE EL PRIMER VALOR==>"); scanf("%d",&a);
gotoxy(10,7); printf("INGRESE EL SEGUNDO VALOR==>"); scanf("%d",&b);
suma=a+b;
Se realiza la operacin
gotoxy(10,9); printf("EL RESULTADO ES==>%d",suma);

break;
Cierra primer proceso
case 2:
Segunda opcin
clrscr();
Limpia pantalla
borde();
Llama al borde
Imprime resultado
if(a>b)
Sentencia selectiva para validar datos
{
resta=a-b;
Se realiza la operacin
gotoxy(10,9); printf("EL RESULTADO ES==>%d",resta);
Imprime resultado
}
else
Caso contrario
{
gotoxy(10,11); printf("ERROR");
Imprime mensaje en caso de no cumplir con la validacin
}
break;
Cierra segundo proceso
case 3:
Abre tercera opcin
clrscr();
Limpia pantalla
borde();
Llama al borde
gotoxy(20,3); printf("3.-MULTIPLICAION");
multi=a*b;
Operacin
gotoxy(10,9); printf("EL RESULTADO ES==>%d", multi);

break;
Cierra tercera opcin

Abre cuarta opcin
Imprime resultado

case 4:
clrscr();
Limpia pantalla
borde();
Llama al borde
if(a>b)
Para validar datos
{
Operacin
divi=a/b;
gotoxy(10,9); printf("EL RESULTADO ES==>%2.2f", divi);
Imprime resultado
}
else
Caso contrario
{
gotoxy(10,9); printf("ERROR");
Imprime mensaje en caso de no cumplir con la validacin
}
break;
Cierra cuarta opcin
case 5:
Abre quinta opcin
exit(0);
Para sealar que debe salir
break;
Cierra quinta opcin
Cierra ciclo switch
gotoxy(10,20);
printf("PRESIONE 1 PARA REPETIR EL PROGRAMA CASO CONTRARIO 0==>");
scanf("%d",&op);
}
-while(op==1);
Cierra ciclo do while
getch();
}
ANALISIS
Espera que se presione cualquier otra tecla para

finalizar
En ese programa se utiliza un menu de opciones para indicar las diferente alternativas que hay y se
un sentencia selectiva llamada switch que sirve para que escoja no de lo procesos que se debe
realizar, se utiliza el ciclo do while para repetir el proceso tantas veces quiera el usuario.

CORRID

PROGRAMA N.24.- Disee
un programa con un men de opciones que me

permita calcular las reas y permetros de las 4 figuras bsicas:
circulo, cuadrado, triangulo, rectngulo.
CODIFICACION:
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
void borde()
Funcin especficamente para el
borde
Declaracin de variable para el borde
int i;
for(i=1;i<=80;i++)
{
Utilizamos el ciclo for para disear el

}
margen de la pantalla en donde
for(i=1;i<=24;i++)
sealamos el numero en el que empieza
y hasta que numero va a llegar,
ubicamos coordenadas e imprimimos en
}
}
void main()
{
int ar,per,op,c,d,r,h,a,resultado,b;
float pi=0.00,perimetro=0.00,area=0.00;
do
{
Para trabajar con variables que tengan
decimales
clrscr();
Limpia
borde();
Lama
pi=3.141592654;
Indicamos el valor de

gotoxy(20,3); printf("MENU DE OPCIONES *** FIGURAS GEOMETRICAS");
gotoxy(10,5); printf("1.-AREA Y PERIMETRO DEL CUADRADO");
gotoxy(10,7); printf("2.-AREA Y PERIMETRO DEL RECTANGULO");
gotoxy(10,9); printf("3.-AREA Y PERIMETRO DEL CIRLCULO");
gotoxy(10,11); printf("4.-AREA Y PERIMETRO DEL TRIANGULO");
Proceso del
opciones
gotoxy(10,13); printf("5.-SALIR");
gotoxy(10,15); printf("INGRESE LA OPCION==>");
scanf("%d",&op);
switch(op)
Variable selectiva sirve para elegir una de las funciones

{
case 1:
Para sealar el primer proceso
clrscr();
Limpia pantalla
borde();
Llama al borde
gotoxy(20,3); printf("1.-AREA Y PERIMETRO DEL CUADRADO");

gotoxy(10,5); printf("***AREA***");
gotoxy(10,7); printf("INGRESE EL VALOR==>"); scanf("%d",&a);
ar=a*a;
Se realizan las operaciones
per=4*a;
gotoxy(10,9); printf("EL AREA ES==>%d",ar);
gotoxy(10,11); printf("***PERIMETRO***");
Imprime resultado
gotoxy(10,13); printf("EL PERIMETRO ES==>%d",per);

break;
Cierra primer proceso
case 2:
Segunda opcin
clrscr();
Limpia pantalla
borde();
Llama al borde
gotoxy(20,3); printf("2.-AREA Y PERIMETRO DEL RECTANGULO");

gotoxy(10,7); printf("INGRESE LA BASE==>"); scanf("%d",&b);
gotoxy(10,9); printf("INGRES LA ALTURA==>"); scanf("%d",&a);
ar=b*a;
Se realizan las operaciones
per=2*(b+a);
men
de

Imprime resultado

break;
Cierra segunda opcin
case 3:
Tercera opcin
clrscr();
Limpia pantalla
borde();
Llama al borde
gotoxy(20,3); printf("3.-AREA Y PERIMETRO DEL CIRCULO");

gotoxy(10,7); printf("INGRESE EL VALOR==>"); scanf("%d",&r);
area=pi*r*r;
Operacin
gotoxy(10,9); printf("EL AREA ES==>%2.2f",area);
Imprime resultado
gotoxy(10,13); printf("INGRESE EL VALOR==>"); scanf("%d",&d);
perimetro=pi*d;
Operacin
gotoxy(10,15); printf("EL PERIMETRO ES==>%2.2f",perimetro);

break;
Cierra tercera opcin
case 4:
Cuarta opcin
clrscr();
Limpia pantalla
borde();
Llama al borde
Imprime resultado
gotoxy(20,3); printf("4.-AREA Y PERIMETRO DEL TRIANGULO");

gotoxy(10,7); printf("INGRESE LA BASE==>"); scanf("%d",&b);
gotoxy(10,9); printf("INGRESE LA ALTURA==>"); scanf("%d",&h);
ar=(b*h)/2;
Operacin
Imprime resultado
gotoxy(10,15); printf("INGRESE TERCER VALOR==>"); scanf("%d",&c);
per=h+b+c;
Operacin
Imprime resultado

break;
Cierra cuarta opcin
case 5:
Quinta opcin
exit(0);
break;
Para indicar que debe salir

Cierra quinta opcin
}
Cierra ciclo switch
gotoxy(10,23); printf("PARA REPETIR EL PROCESO PRESIONE 1 CASO CONTRARIO 0==>");
scanf("%d",&op);
}
Cierra ciclo do while
while(op==1);
getch();
Espera que se presione cualquier otra tecla para
finalizar
ANALISIS
Este programa utiliza un men de opciones de las reas y permetros de las figuras geomtricas,
utilizamos una sentencia selectiva switch para que seleccione el proceso que debe realizar, al inicio
se declara a la variable pi con s valor ara que se pueda ejecutar correctamente en el momento de
realizar la operacin, se utiliza un ciclo do while para que el proceso se repita tantas veces quiera el
usuario
CORRIDO
Programa 25
Disee un programa a travs de un men de opciones que me permita calcular las 6
operaciones bsicas con sus respectivas validaciones. Estas son suma, resta, multiplicacin,
divisin, potenciacin y radicacin.
ANLISIS
Suma h=b + a;
H=2+5
H=7
Resta H = b a;
b>a h= 5-2
h= 3
Divisin h=b/a;
b>a
h=6/3
h=2
Potenciacin h=
h=
h=8
Multiplicacin h = a*b
h= 3*4
h= 12
Radicacin
h=
h=
h=8
CODIFICADO:
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
ACTIVACIN DE LIBRERAS
Gestin de memoria dinmica, control de procesos y otras.
Activa la cadena de caracteres.
Inicializa el programa.
void borde()
{
int i;
for(i=1;i<=80;i++)
{
Inicializa la funcin del borde.
}
Declaracin de variables.
for(i=1;i<=24;i++)
{
Inicializacin del for.
}
}
void main ()
Inicializacin del programa.
{
int op,i,a,p,h,j,w,x,y,z,b;
Declaracin de variables.
Inicializamos; j=1;
j=1;
Limpiar la pantalla
Impresin del borde

clrscr();
borde();
gotoxy(35,1);printf("EJERCICIO N.-");
gotoxy(20,3);printf("**MENU DE OPERACIONES BASICAS**");
gotoxy(25,6);printf("1.- SUMA ");
gotoxy(25,7);printf("2.- RESTA");
gotoxy(25,8);printf("3.- MULTIPLICACION");
gotoxy(25,9);printf("4.- DIVICION");
gotoxy(25,10);printf("5.- POTENCIACION");
gotoxy(25,10);printf("6.- RADICACION ");
gotoxy(25,10);printf("7.- SALIR");
gotoxy(25,13);printf("INGRESE UNA OPCION : ");scanf("%d",&op);
switch(op)
{
case 1:
IMPRESIN DE
DATOS
Impresin y lectura
Inicializacin del switch

Inicializacin de switch
clrscr();
borde();
gotoxy(35,2);printf("***SUMA***");
gotoxy(25,6);printf("INGRESE EL PRIMER VALOR : ");scanf("%d",&b);
gotoxy(25,7);printf("INGRESE EL SEGUNDO VALOR: ");scanf("%d",&a);
h=b+a;
gotoxy(48,8);printf(" ---");
gotoxy(38,9);printf(" RESPUESTA : %d",h);
break;
case 2 :
clrscr();
borde();
gotoxy(35,2);printf("***RESTA***");
gotoxy(25,6);printf("INGRESE EL PRIMER VALOR : ");scanf("%f",&b);
gotoxy(25,7);printf("INGRESE EL SEGUNDO VALOR: ");scanf("%f",&a);
h=b-a;
gotoxy(38,9);printf(" RESPUESTA : %f",h);
break;
case 3 :
clrscr();
borde();
gotoxy(35,2);printf("***MULTIPLICACION***");
h=b*a;
Inicializaci
n limpiar la
pantalla
impresin
del
borde
impresin y
proceso de
suma
Inicializaci
n del case2
limpiar
la
pantalla
proceso de
la resta e
impresin
Proceso
impresin de la
multiplicacin

break;
case 4 :
clrscr();
borde();
gotoxy(35,2);printf("***DIVISION***");
do{
gotoxy(25,6);printf("INGRESE EL PRIMER VALOR : ");
gotoxy(25,7);printf("INGRESE EL SEGUNDO VALOR: ");
}while(a>b);
e=b/a;
gotoxy(38,9);printf(" RESPUESTA : %f",e);
break;
case 5 :
clrscr();
borde();
gotoxy(35,2);printf("***POTENCIACION***");
gotoxy(25,6);printf("INGRESE EL VALOR : ");scanf("%f",&b);
gotoxy(25,7);printf("INGRESE LA POTENCIA: ");scanf("%f",&a);
h=pow(b,a);
break;
case 6 :
clrscr();
borde();
gotoxy(35,2);printf("***RADICACION***");
h=sqrt(b);
break;
case 7 :
exit(0);
break;
/*inicializa el case 7
/*sale del programa
/* Finaliza el switch
default:
clrscr();
/*caso contrario
/* limpia la pantalla
Finaliza
Inicializa
el
el
case 4 lectura
proceso
impresin de la
divisin
validacin
de
los valores a>b
Inicializa
el
case 5 lectura
proceso
impresin de
la
Inicializa
el
case 6 lectura
proceso
impresin de la
potenciacin

gotoxy(38,12);printf("***ERROR***");
/* imprime error
}
/*cierra la llaves de switch
gotoxy(28,23);printf("PRESIONE (1) PARA VOLVER AL MENU: ");scanf("%d",&mk);
}while(mk==1);
/*imprime y cierra el while valida
la opcin/*
getch();
/* hace una pausa
}
}
getch();
}
CORRIDO
Programa 26
Disee un programa que me permita realizar las conversiones bsicas: metros, kilmetros,
decmetros, hectmetros.

Analisis:
KM
DM
M
Cm
Mm
DM; M; Cm; Mm.

km; M; Cm; mm
km; Dm; Cm; mm
km; Dm; M; mm
km; Dm; M; Cm
Codificacin:
#include<conio.h>
#include<stdio.h>
Activacin de libreras y
#include<string.h>
comienzo del programa
#include<stdlib.h>
#include<math.h>
void borde()
{
int i;
for(i=1;i<=80;i++)
Realizacin del Borde con
{
funcin
}
for(i=1;i<=24;i++)
/*for inicializa en 1 hasta 24
{
/*abrimos la llave del for
/*impresin de * en la columna 1 fila i++
/*impresin de * en la columna 80 fila i++
}
}
void main ()
/*inicializacin del programa
{
/* llaves de inicio de programa
int op,i,p,j,w,x,y,z,mk;
float a,e,b,h,d,cm,mm,m,k,dm;
j=1;
/* inicializacion de j en 1
do
/*inicialisa el do
{
clrscr();
/*borrado de pantalla
borde();
/*llamado a la funcin borde
textcolor(BLUE);
/* color azul del texto
gotoxy(35,1);printf("EJERCICIO N.-");
gotoxy(25,3);printf("**MENU DE CONVERCIONES BASICAS**");
gotoxy(25,6);printf(" EL VALOR A INGRESAR ES EN:");
gotoxy(25,7);printf("1.- KILOMETROS");
Impresin
gotoxy(25,8);printf("2.- DECAMETROS ");
men
del

gotoxy(25,9);printf("3.- METROS");
gotoxy(25,10);printf("4.- CENTIMETROS");
gotoxy(25,11);printf("5.- MILIMETROS ");
gotoxy(25,13);printf("INGRESE UNA OPCION : ");scanf("%d",&op); /*lectura de opcin
switch(op)
/* inicio del switch con la opcin escogida
{
/* llaves de inicio de switch
case 1:
clrscr();
Inicio de case 1
borde();
Borrado
de
gotoxy(28,2);printf("***VALOR EN KILOMETROS***");
pantalla funcin
de
borde
d=b/0.01;
impresin
del
m=b/0.001;
titulo lectura del
cm=b/0.00001;
mm=b/0.000001;
valor
en
km
gotoxy(30,5);printf(" KM : %f",b);
proceso
para
gotoxy(30,6);printf(" DM : %f",d);
calcular las demas
gotoxy(30,7);printf(" M : %f",m);
gotoxy(30,8);printf(" cm : %f",cm);
gotoxy(30,9);printf(" mm : %f",mm);
break;
case 2 :
Inicializacin de case
clrscr();
borde();
borrado
de pantalla
gotoxy(28,2);printf("***VALOR EN DECAMETROS***");
funcin
borde
impresin
del
ttulo
k=b*100;
lectura del valor en DC
m=b/0.001;
proceso
para
la
cm=b/0.00001;
transformacin.
mm=b/0.000001;
gotoxy(30,5);printf(" KM : %f",k);
Impresin de resultados.
gotoxy(30,6);printf(" DM : %f",b);
break;
Inicializacin de
case 3 :
clrscr();
case 3 borrado
borde();
de
pantalla
gotoxy(28,2);printf("***VALOR EN METROS***");
funcin
borde
impresin
del
k=b*0.001;
ttulo
lectura
del valor en M
proceso para la
transformacin.

dm=b*0.1;
cm=b*100;
mm=b*1000;
gotoxy(30,6);printf(" DM : %f",dm);
gotoxy(30,7);printf(" M : %f",b);
break;
case 4 :
Inicializacin de
clrscr();
borde();
case 3 borrado
gotoxy(28,2);printf("***VALOR EN CENTIMETROS***");
de
pantalla
funcin
borde
k=b*0.0001;
impresin
del
dm=b*0.01;
ttulo
lectura
m=b/100;
mm=b*10;
proceso para la
transformacin.
Impresin
de
resultados.
gotoxy(30,8);printf(" cm : %f",b);
break;
case 5 :
clrscr();
borde();
gotoxy(28,2);printf("***VALOR EN CENTIMETROS***");
k=b*0.00001;
dm=b*0.001;
m=b/1000;
mm=b*100;
gotoxy(30,8);printf(" cm : %f",mm);
gotoxy(30,9);printf(" mm : %f",b);
break;
case 6 :
// inicia el case 6
Inicializacin de
case 5 borrado
de
pantalla
funcin
borde
impresin
ttulo
del
lectura
del valor en mm
proceso para la
transformacin.
Impresin
resultados
de

exit(0);
// sale del programa
break;
// finalize el switch
default:
// caso contrario
clrscr();
// borrado de pantalla
gotoxy(38,12);printf("***ERROR***"); // imprime error
}
gotoxy(28,23);printf("PRESIONE (1) PARA VOLVER AL MENU: ");scanf("%d",&mk);
}while(mk==1);
// lectura de mk en while
getch();
//pausa
}
// llave que finaliza el programa
CORRIDO
Programa 27
Disee un programa que me permita generar el siguiente men de opciones de la siguiente
comprobacin de los siguientes nmeros :
1. Nmeros Pares
2. Nmeros Impares
3. Nmeros primos
4. Salir
Anlisis :
Nmeros pares =0+2=2+2=4+2=6..N
Nmeros impares=1+2=3+2=5+2=7...N
Nmeros primos= 1,3,5,7.n
Codificacin:
#include<conio.h>
#include<stdio.h>
Activacin de libreras

#include<stdlib.h>
int limite,op,i,resulpar,n,numpar,ni,numimpar,r,cont,np; //declaracin de variables
void borde()
{
funcin del borde
for(i=1;i<=80;i++)
{
inicio del for con incremento i++; hasta 80
impresin de *
}
for(i=1;i<=24;i++)
Inicio de for con incremento i++; hasta 24
{
Impresin de *
}
}
void numerospar (int numpar1)
// function para numerous par
{
//inicio
resulpar=n%2;
// coje el resioduo de n/2
if(resulpar==0)
// si en residuo es 0
{
gotoxy(29,6);printf("EL NUMERO %d ES PAR",n); //imprime par
}
else
{
gotoxy(28,6);printf("EL NUMERO %d ES IMPAR",n); //caso contrario imprime impar
}
}
void numerosimpar (int numimpar1)
// funcin de numeros impares
{
// inicio
resulpar=n%2;
// residuo =1
if(resulpar==1)
{
gotoxy(29,6);printf("EL NUMERO %d ES IMPAR",n);//imprime es par
}
else
{
gotoxy(28,6);printf("EL NUMERO %d ES PAR",n); //caso contrario es impar
}
//cierre del ese
}
// fin de la funcion
void numpri (int np1)
//funcion para numero primo
{
// inicio
cont=0;
// cont inicializa en 0
for(i=1;i<=n;i++)
// inicia en 1 hasta n si suma i++

{
r=n%i;
if(r==0)
//si el residuo es 0
{
cont=cont+1;
// contador vale 1 y v air sumand 1+1
}
}
if(cont==2)
// contador vale 2
{
gotoxy(30,5);printf("EL NUMERO %d ES PRIMO",n);//imprime es primo
}
else
//caso contrario
{
gotoxy(30,5);printf("EL NUMERO %d ES PRIMO",n); //imprime no es primo
}
}
void main()
inicia el programa
{
do{
clrscr();
borde();
gotoxy(28,2);printf("MENU DE VERIFICACION");
gotoxy(20,4);printf("1.- VERIFICACION DE NUMEROS PARES");
gotoxy(20,5);printf("2.- VERIFICACION DE NUMEROS INPARES");
Impresin
del
gotoxy(20,6);printf("3.- VERIFICACION DE NUMEROS PRIMOS");
menu
gotoxy(20,8);printf("ELIJA UNA OPCIONN : ");scanf("%d",&op);
//lectura de op
switch(op)
{
case 1 :
Case 1 borrado de pantalla
clrscr();
borde();
Funcin borde impresin
gotoxy(28,2);printf("VERIFICACION DE PARES");
del ttulo lectura de n
gotoxy(28,4);printf("INGRESE UN NUMERO : ");scanf("%d",&n);
llamado a la funcin.
numerospar(numpar);
break;
case 2 :
clrscr();
borde();
gotoxy(28,2);printf("VERIFICACION DE IMPARES");
numerosimpar(numimpar);

break;
case 3 :
clrscr();
borde();
gotoxy(28,2);printf("VERIFICACION DE PRIMOS");
numpri(np);
break;
case 4:
exit(0);
// sale del programa
break;
default :
// caso contrario
clrscr();
gotoxy(30,12);printf("***ERROR***");
// imprime error
gotoxy(20,21);("PRESIONE (1) PARA VOLVER AL MENU");
break;
}
gotoxy(20,21);("PRESIONE (1) PARA VOLVER AL MENU");
scanf("%d",&op);
}while(op==1);
getch();
}

CORRIDO:
Programa 28
Disee un programa que me permita realizar un borde utilizaciones funciones.
Analisis-:
Utilizacion de for en:
filas hasta 24
Columnas hasta 80

Codificado:
#include<conio.h>
Activacin de libreras
#include<stdio.h>
int i; //declaracin de variables
void borde()
{
funcin del borde
for(i=1;i<=80;i++)
{
inicio del for con incremento i++; hasta 80
impresin de *
}
for(i=1;i<=24;i++)
Inicio de for con incremento i++; hasta 24
{
Impresin de *
}
}
Void main ()
//inicio del programa
{
clrscr();
borde();
// funcin borde
printf(borbe);
// impresin borde
}
getch();
CORRIDO:
Programa 29
Disee un programa utilizando funciones que me permita generar n nmeros naturales
Anlisis:
utilizacin de un ciclo for

con un limite n
en una sola funcin
con dos variables i n
Codificacin:
#include<conio.h>
Activacin
de
#include<stdio.h>
int limite,op,i,fila,col; // declaracin de variables
void borde()
{
for(i=1;i<=80;i++)
{
}
Funcin borde
for(i=1;i<=24;i++)
{
}
}
void numeros (int limite1)
{
col=20;
//columna inicia en 20
fila=5;
// fila inicia en 5
for(i=1;i<=limite1;i++)
inicia 1 hasta n I aumenta i++
{
gotoxy(col,fila);printf("%d",i); //imprime i
fila=fila+1;
//fila incrementa +1
if(fila==18)
//si la fila llega a 18 se aumenta 10
{
Funcin
naturales
nmeros

col=col+10;
fila=7;
}
}
}
void main ()
{
clrscr();
borde();
gotoxy(20,2);printf("SERIE DE NUMEROS");
gotoxy(15,4);printf("INGRESE UN LIMITE : ");scanf("%d",&limite);
numeros (limite);
getch();
}
CORRIDO:
Impresin del
ttulo funcin
limite

CORRIDO:
Programa 30
Disee un programa utilizando funciones que me permita calcular el valor de las comisiones
por venta de vehculos segn los siguientes condicionamientos, existen 3 vendedores, el
vendedor 1, el vendedor 2, el vendedor 3, se asigna un valor de comision si:
La venta es 8500 y 13500 la comisin es del 3%
La venta es > 13500 y 18000 la comisin es del 8%
La venta es > 18000 la comisin es del 11%
Obtenga el nmero de ventas realizadas por vendedor, el total de ventas realizadas, el total de
comisiones recibidas y el total general de todas las comisiones.
Analisis:
Se utilizara funciones, condiciones, ademas de eso se imprimira el borde de pantalla.
Las condiciones sern:
La venta es 8500 y 13500 la comisin es del 3%
La venta es > 13500 y 18000 la comisin es del 8%
La venta es > 18000 la comisin es del 11%
para los tres vendedores
CoDIFIcado:
#include<stdio.h>
Activacin
librerias
de

#include<conio.h>
#include<stdlib.h>
int i,op,op1,cont1,q;
// declaracion de variables enteras
float tv,venta,val,contv; // declaracion de variables flotantes
void borde()
Inicio del borde
{
for(i=1;i<=80;i++)
Inicia el for hasta 80 con un incremento de i++
{
Impresin de *
}
Impresin de *
for(i=1;i<=24;i++)
Inicia el segundo for hasta 24 con el incremento
{
de i++
gotoxy(1,i);printf("");
Imprime *
}
}
void v1(int ven)
// inicia funcin int ven
{
//llave de inicio de la funcin
if(venta<8500)
//primera condicin
{
no realiza nada con esta condicin
}
Else
//caso contrario
{
// llave inicio del else
if(venta>=8500 && venta<=13500) // proceso un nuevo if
{
// llave de inicio del if
tv=venta*0.03;
//proceso
}
// termina el if
Else
// caso contrarion
{
//nueva proceso
if(venta>13500 && venta<=18000)//condicion
{
// llave de inicio
tv=venta*0.08;
//proceso
}
//termina if
else
//caso contrario
{
//llave de inicio
tv=venta*0.11;
//proceso
}
}
cierre de los 2 if
Y de la funcion
}
}
void main()

{
Inico del programa, declaracion de q=0,
q=0;
do
borrado de pantalla, impresin del
{
borde
q=q+1;
clrscr();
borde();
gotoxy(30,3);printf("COMISIONES POR VENTAS DE VEHICULOS");
gotoxy(10,5);printf("1.Vendedor 1");
Impresin
de datos
gotoxy(10,8);printf("4.Total de ventas");
gotoxy(10,9);printf("5.Salir");
gotoxy(10,10);printf("Elija opcion: ");scanf("%d",&op);
switch(op)
{
ytcont1=0;
contv=0;
val=0;
do
{
Inicio del switch

Iniciacin de variables en 0
Inico de un ciclo do
case 1:
// inicio de case 1
clrscr();
// borrado de pantall
borde();
//llama la funcion borde
cont1=cont1+1;
//cont va ir sumando cada vez que se repita
gotoxy(10,5);printf("Vendedor 1: ");scanf("%f",&venta); //impresin y lectura de
datos
v1(venta);
// llama la funcion venta
contv=contv+tv;
//va ir incrementado cada vez que se repita
val=val+venta;
// va ir incrementado cada vez que se repita
gotoxy(15,20);printf("Desea insertar otra venta 1/0: ");scanf("%d",&op1);
}while(op1==1);
// evala la opcin escogida
break;
// filaliza el switch
do
{
case 2:
// inicio de case 2
clrscr();
// borrado de pantalla
borde();
// llamado a la funcion bnorde
cont1=cont1+1;
gotoxy(10,5);printf("Vendedor 2: ");scanf("%f",&venta);
v1(venta);

contv=contv+tv;
val=val+venta;
}while(op1==1);
// evala la opcin escogida
break;
// filaliza el switch
do
{
case 3:
clrscr();
borde();
cont1=cont1+1;
gotoxy(10,5);printf("Vendedor 3: ");scanf("%f",&venta);
v1(venta);
contv=contv+tv;
val=val+venta;
}while(op1==1);
break;
case 4:
clrscr();
borde();
Impresin
gotoxy(15,6);printf("Total ventas: %d",cont1);
resultados
gotoxy(15,7);printf("Total comicion: %2.2f",contv);
gotoxy(15,8);printf("Total valor: %2.0f",val);
break;
case 5: //case 5
exit(0); // sale del programa
break;
}
}while(op==1); // evalua la opcion escojida
getch();
}
Corrido:
Case
limpia
pantalla
llama
borde
Contadore
s
de
Programa 32
Disee un programa permita obtener el valor a pagar por concepto consumo de agua potable
segn el siguiente condicionamiento.
Se ingresa desde teclado el nombre del abonado y las lecutras del medidor del mes antesior y
del mes actual, considerando siempre que la lecutura actual no puede ser menor que la anterio,
la diferenciaentre las dos lecturas me permite obtener el consumo actual las mismas que tiene
el siguiente condicionamiento
Si el consumo es 30 litros de agua, se le factura el valor minimo que son Usd. 6,00
Si el consumo es > 30 y que 200 se cobra, 1,50 centavos cada litro de agua
Si el cosnumo es > 200 litros se cobra 2,75 cada litro
A este importe total obtenido se le aade los impuestos de ley
5% Basurero
%5 IECE
3% Municipio
Obtenga el costo total de la factura
El programa debe funcionar para n usuarios al final se visualiza el nmero
total de
usuarios recaudados y el valor total recaudado.
CODIFICADO:
#include<conio.h>
Activacin de librerias
#include<stdio.h>
#include<stdlib.h>
int op,i,tr=0,valor,cuenta,tao,n=0,consumo,l1,l2,consumo1,consumo2,muni,bas,iece;//
declaracion de variables
char nom; // declaracion de caracteres
void borde()
{
for(i=1;i<=80;i++)
{
Funcin borde
}
for(i=1;i<=24;i++)
{
}
}
void decis (int consumo2)
{
if(consumo2<30)

{
Inicio
de
la
funcin
valor=6;
llave de inicio de la funcin
}
if(consumo2>30 && consumo2<=200)
Condicin c<3 Valor va ser 6
{
valor=(consumo2*1.50)+consumo2;
Condicin c>30yc<=200
}
Proceso
if(consumo2>200)
{
Condicin c>200
valor=(consumo2*2.75)+consumo2;
}
proceso
}
void main()
// inicio del programa
{
Inicio de ciclo do
do
{
Borrado de pantalla
clrscr();
borde();
Llamado a la funcin borde
gotoxy(30,2);printf("**EMPRESA MUNICIPAL DE AGUA POTABLE**");
n=n+1;
// va ir sumando 1 +1
gotoxy(18,4);printf("%d",n);
// lecura de datos
gotoxy(20,4);printf("INGRESE SU NOMBRE : ");scanf("%s",&nom);
gotoxy(3,5);printf("lectura de consumo del mes de septimbre : ");scanf("%d",&consumo1);
do{
gotoxy(3,6);printf("lectura de consumo del mes de octubre
");
gotoxy(3,6);printf("lectura de consumo del mes de octubre : "); scanf("%d",&consumo2);
}while(consumo2<consumo1);
decis (consumo1);
// llamado a la funcin concumo
gotoxy(5,10);printf("valor consumo es de: %d",valor);// impresin de valores
bas=valor*0.05;
iece=valor*0.05;
proceso
muni=valor*0.03;
tao=valor+bas+iece+muni;
gotoxy(5,11);printf("valor basura : %d",bas);
gotoxy(5,12);printf("valor IECE : %d",iece);
gotoxy(5,13);printf("valor MUNICIPIO: %d",muni);
gotoxy(5,14);printf("valor TO A PAG : %d",tao);
tr=tao++
impresin de datos
gotoxy(50,20);printf("N USUARIOS : %d",n);
gotoxy(50,21);printf("total recaudado : %d ",tr);
gotoxy(20,22);printf("presione 1 para continuar: ");scanf("%d",&op);
}while(op==1);
getch();
Impresi
n
de

}
CORRIDO:
ELEMENTO 3
http://www.youtube.com/watch?v=sMy7EbJlhp4
ELEMENTO 4
Funciones vectores matrices
PROGRAMA 33
1. ENUNCIADO
Disee un programa utilizando funciones que me permita ingresar 3 valores enteros desde
teclado entre 4 y 64 y presentarlos en forma ordenada ascendentemente.
2. ANALISIS
Para este programa se necesitan varias funciones de condicin if para hacer la comparacin
y as poder imprimir los nmeros en forma ascendente y para validar los nmeros tambin
otros if para que el nmero ingresado este el rango que se peda en el programa
3. DOCUMENTACION
#include<stdio.h>
LIBRERIA
#include<conio.h>
int i,a,b,c,op;
void borde()
Inicio de la funcin borde
{
for(i=1;i<=80;i++)
inicio del for
{
gotoxy(i,1);printf("");
}
for(i=1;i<=24;i++)
{
Impresin del margen
}
}
void numero()
Inicio de la funcin void main
{
do
Inicio del do
{
");
Ingreso el primer numero
gotoxy(15,4);printf("Numero 1; ");scanf("%d",&a);
}
Si ese numero cumple con la
while(a>64 || a<4);
condicin empleada pide el

siguiente numero
do
Inicio del do
{
");
Ingreso el segundo numero
gotoxy(15,5);printf("Numero 2: ");scanf("%d",&b);
}
Si ese numero cumple con la
while(b>64 || b<4);
condicin empleada pide el

siguiente numero
do
Inicio del do
{
");
gotoxy(15,6);printf("Numero 3: ");scanf("%d",&c);
Ingreso el tercer numero
}while(c>64 || c<4);
}
void orden()
Inicio de la funcin void
{
if(a<=b && a<=c)
{
if(b<=c)
{
gotoxy(15,8);printf("%d %d %d",a,b,c);
}
if(c<=b)
{
gotoxy(15,8);printf("%d %d %d",a,b,c);
}
Proceso para presentar
}
los
nmeros
if(b<=a && b<=c)
ingresados en forma
{
ordenada
if(a<=c)
ascendentemente.
{
gotoxy(15,8);printf("%d %d %d",b,a,c);
}
if(c<=a)
{
gotoxy(15,8);printf("%d %d %d",b,c,a);
}
}
if(c<=a && c<=b)
{
if(a<=b)
{
gotoxy(15,8);printf("%d %d %d",c,a,b);
}
if(b<=a)
{
gotoxy(15,8);printf("%d %d %d",c,b,a);
}
}
gotoxy(15,7);printf("El orden es:");
}

void main()
{
do
{
clrscr();
borde();
Inicio de la funcin principal
Borrar
Llamar
al borde
pantalla
Llamar a la
numero();
orden();
funcin
Llamar numero
a la funcin

}
while(op==1);
Si la opcin ingresada por el usuario es igual a 1
el proceso se repetir
getch();
}
Fin del programa
4. CORRIDO DEL PROGRAMA
PROGRAMA 34
1. ENUNCIADO
Disee un programa utilizando funciones que me permita generar y visualizar los nmeros perfectos.
2. ANALISIS
En este programa utilizamos la librera math porque utilizamos la funcin pow

Utilizamos un do while para que el usuario ingrese otro limite o quiera salir del
programa
Aqu tambin empleamos la utilizacin de las funciones
3. DOCUMENTACION
#include<stdio.h>
LIBRERIA
#include<conio.h>
#include<math.h>
int i,r,dos=2,ex=1,ex2=2,s,v,l1,expo2=2,expo3=3,a,b,c,f=9,i,op;
void borde()
{
for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)
{
}
}
Inicio de la funcin
Impresin del margen
Inicio de la funcin void

void perfecto(int l)
perfecto
{
r=pow(dos,ex);
Operaciones para sacar
s=pow(dos,ex2);
los nmeros perfectos
v=r*(s-1);
gotoxy(7,8);printf("%d",v);
for(i=1;i<=l-1;i+
{
a=pow(dos,expo2);
Operaciones para sacar
b=pow(dos,expo3);
los nmeros perfectos
expo2=expo2+2;
expo3=expo3+2;
c=a*(b-1);
Impresin de los nmeros
gotoxy(7,f);printf("%d",c);
perfectos

f=f+1;
}
}//cierre del void
Inicio de la funcin principal

void main()
{
do
{
f=9,dos=2,ex=1,ex2=2,expo2=2,expo3=3,f=9;
Borrar
clrscr();
Llamar al borde
borde();
gotoxy(30,4);printf("SERIE DE NUMEROS PERFECTOS");
gotoxy(5,6);printf("Ingrese un limite: ");scanf("%d",&l1);
Llamo a la funcin perfecto
Impresin del
Ingreso del limite
perfecto(l1);
");
gotoxy(4,22);printf("PRESIONE 1 PARA VOLVER AL MENU O 0 PARA SALIR: ");scanf("%d",&op);
}
while(op==1);
Si la opcin ingresada por el usuario es igual a 1
getch();
}
Fin del
el proceso se repetir
programa
4. CORRIDO DEL PROGRAMA
Programa 35
ENUNCIADO
Disee un programa utilizando funciones que me permita resolver un sistema de ecuacin
de 2 grado.
Anlisis.
Partiremos escribiendo la frmula para tener base de que noms se va a utilizar.
La frmula genera dos respuestas: Una con el signo ms (+) y otra con el signo menos
() antes de la raz. Solucionar una ecuacin de segundo grado se limita, entonces, a
identificar las letras a, b y c y sustituir sus valores en la frmula.
La frmula general para resolver una ecuacin de segundo grado sirve para resolver
cualquier ecuacin de segundo grado, sea completa o incompleta, y obtener buenos
resultados tiene que ver con las tcnicas de factorizacin.
Codificacin.
#include <stdio.h>
#include <stdlib.h>
Activation de Liberia
#include <conio.h>
#include <math.h>
int i,j,op;
// declaracin de variables globales
void borde()
{
textcolor(BLUE);
for(i=1;i<=80;i++)
{
gotoxy(i,1);cprintf("*");
funcin del borde
for(i=1;i<=24;i++)
{
gotoxy(1,i);cprintf("*");
// impression de *

}
// fin del ciclo for
// fin de la function borde
void seg ()
// function para la ecuacion
// inicio de la function
float a, b, c;
float x1, x2;
float x1real, x2real;
/* complejas
*/
float x1imag, x2imag;
/* Partes imaginarias soluciones complejas */
float discriminante;
/* Presentacion */
system ("cls");
/* Borrado de la pantalla */
borde();
gotoxy(10,3);printf("RESOLUCION DE LA ECUACION DE SEGUNDO GRADO\n");
gotoxy(2,4);printf("========================================================
======\n");
gotoxy(10,5);printf("El programa soluciona la ecuacin de segundo grado\n");
\n");
gotoxy(10,7);printf("ax + bx + c = 0
\n");
/* Peticin de datos */
printf("Introduzca los coeficientes:\n");

printf(" Coeficiente a: "); scanf("%f", &a);
printf(" Coeficiente b: "); scanf("%f", &b);
printf(" Coeficiente c: "); scanf("%f", &c);
discriminante = b*b - 4*a*c;
/* Clculos y resultados */
// calculo de discriminate
printf("\n La ecuacion\n");
printf(" %14d\n", 2);
printf(" %12gx + %gx + %g = 0\n", a, b, c); // impresiones
printf(" tiene por soluciones ");
if (discriminante == 0)
// sentencia si dis es = a 0

{
// inicio de if
printf(" una raiz real doble\n"); // impresin
x1 = x2 = -b / (2*a);
// calculo
printf(" x1 = %.2f\n", x1);

printf(" x2 = %.2f\n", x2);
// impresin en pantalla
// fin de if
else if (discriminante > 0)
//si dis es mayor a cero
// clculos
printf(" dos raices reales\n");
x1 = (-b + sqrt(discriminante)) / (2*a);
x2 = (-b - sqrt(discriminante)) / (2*a);
// impresiones
printf("x1 = %.2f\n", x1);
printf("x2 = %.2f\n", x2);
}
Else
{
// caso contrario
//impresin en pantalla
printf("dos races complejas conjugadas\n");
//clculos
x1real = x2real = -b / (2*a);
x1imag = sqrt(-discriminante) / (2*a);
x2imag = -sqrt(-discriminante) / (2*a);
// impresiones
printf("x1 = ( %.2f, %.2fi)\n", x1real, x1imag);
printf("x2 = ( %.2f, %.2fi)\n", x2real, x2imag);
}
}
void main ()
{
//fin del ese

// fin de la funcin
// inicio del programa
// llave de inicio
Do
//ciclo do
// llave de inicio de do

borde ();
seg ();
// funcion borde
// funcion seg
gotoxy(22,22);printf("desea continuar: ");scanf("%d",&op); // impresin en pantalla y lectura

} while(op==1);
getch(); //pausa
} // fin del programa.
Corrido
Programa 36
ENUNCIADO
Disee un programa en C, utilizando funciones que permita:
1.- Obtener la edad de una persona en aos, meses y das
2.-Descomponer un nmero de 4 cifras en todos sus componentes
Anlisis: Para calcular el nmero de aos, meses y das que tiene una persona debemos tener
en cuenta que debemos restar del nmero del ao actual el ao de nacimiento, y de la misma
forma los meses y los das, si uno no nos alcanza para poder restar, debemos pedir prestado
una unidad, bien sea al mes o al aos, dependiendo el orden. Entonces primero ingresamos
por teclado la fecha de nacimiento y la fecha actual, y procedemos a realizar los procesos
mencionados anteriormente. Ahora bien, para descomponer un nmero de 4 cifras, debemos
primero dividir dicho nmero ingresado para 1000 y multiplicarlo por 1000,
(um=(num/1000)*1000), realizamos la divisin con / para tomar solo el nmero entero y al
multiplicarlo por 1000 podremos encontrar la unidad de millar del nmero ingresado, y restar
del nmero ingresado la unidad de millar, (num=num-um), de igual forma ser para encontrar
la centena, (c=(num/100)*100), (num=num-c), la decena ,(d=(num/10)*10), (num=num-d), y
la unidad es lo que nos sobra. Y al final solo visualizamos los resultados.
Documentacin:
#include<conio.h>
#include<stdio.h>
librerias
#include<stdlib.h>
int op, d, m, a, dn, mn, an, a1, dd, mm, aa, mmm, ddd, num, um, c, dec;
void borde()
{
int i;
clrscr();
for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)
{
Funcin borde
}
}
void edad()
{
do
{

gotoxy(11,6);scanf("%d",&dn);
}
while(dn<1 || dn>30);
gotoxy(13,6);printf("/");
do
Proceso de calculo del la
{
edad
gotoxy(14,6);scanf("%d",&mn);
}
while(mn<1 || mn>12);
gotoxy(17,6);scanf("%d",&an);
gotoxy(5,8);printf("Ingrese la fecha actual dd/mm/aa>> ");
do
{
gotoxy(11,9);scanf("%d",&d);
}
while(d<1 || d>30);
Proceso de calculo del la
do
edad
{
gotoxy(14,9);scanf("%d",&m);
}
while(m<1 || m>12);
gotoxy(17,9);scanf("%d",&a);
dd=d-dn+30;
if(dd>30)
{
dd=dd-30;
mm=m-mn+12;
}
else
Condiciones dek proceso
{
mm=m-mn-1+12;
del calculo
if(mm>12)
{
mm=mm-12;
aa=a-an;
}
else
{
aa=a-an-1;
}}
gotoxy(5,13);printf("Usted tiene %d dias",dd);
gotoxy(5,14);printf("Usted tiene %d meses",mm);
gotoxy(5,15);printf("Usted tiene %d anos",aa);
}

void desc()
{
do
{
");
gotoxy(5,5);printf("Ingrese un numero>> ");scanf("%d",&num);
}
while(num<1000 || num>9999);
um=(num/1000)*1000;
gotoxy(5,7);printf("Unidad de millar>> %d",um);
num=num-um;
c=(num/100)*100;
Imprecion en pantalla de resultados
gotoxy(5,9);printf("Centena>> %d",c);
del calculo de la edad
num=num-c;
dec=(num/10)*10;
gotoxy(5,11);printf("Decena>> %d",dec);
num=num-dec;
gotoxy(5,13);printf("Unidad>> %d",num);
}
void main()
{
do
{
clrscr();
borde();
gotoxy(32,3);printf("<<MENU DE OPCIONES>>");
Imprecion en pantalla
gotoxy(5,5);printf("1.- Calcule su edad>>");
de resultados del
gotoxy(5,7);printf("2.- Descomponer un numero de 4 cifras>>");
gotoxy(5,9);printf("3.- Salir>>");
calculo de la edad
do
{
gotoxy(5,11);printf("Que desea realizar>> ");scanf("%d",&op);
}
while(op>3);
switch(op)
{
case 1:
clrscr();
borde();
gotoxy(33,3);printf("<<CALCULE SU EDAD>>");
Imgreso en pantalla
gotoxy(5,5);printf("Ingrese su fecha de nacimiento dd/mm/aa>> ");
de resultados del
edad();
break;
calculo de la edad
case 2:
clrscr();
borde();
gotoxy(33,3);printf("<<DESCOMPOSICION DE UN NUMERO>>");
desc();
break;

case 3:
exit(0);
break;
}
gotoxy(3,22);printf("PRESIONE 1 PARA VOLVER A REPETIR EL PROCESO O 0 PARA
FINALIZAR>> ");scanf("%d",&op);
}
while(op==1);
getch();
Corrido:
Programa 37
ENUNCIADO
Disee un men de opciones utilizando funciones que me permita disear 4 estilos de bordes
diferentes.
Anlisis: Creo un men con opciones para crear los distintos estilos de borde. La primera
opcin ser de un borde simple, la segunda de un borde doble, la tercera de un borde con
encabezado, y la cuarta un borde al gusto del programador. Para realizar los distintos estilos
de borde utilizamos los cdigos ASCII.
Documentacin:
#include<conio.h>
librerias
#include<stdio.h>
#include<stdlib.h>
int op;
void borde()
{
int i;
clrscr();
for(i=1;i<=80;i++)
{
Funcin borde
}
for(i=1;i<=24;i++)
{
}
}
void bsim()
{
int i;
clrscr();
gotoxy(1,1);printf("");
for(i=2;i<=79;i++)
{
Funcin borde
}
for(i=2;i<=23;i++)
{

}
}
void bdob()
{
int i;
clrscr();
for(i=2;i<=79;i++)
{
}
for(i=2;i<=23;i++)
{
}
}
void ep()
{
int i;
clrscr();
for(i=2;i<=79;i++)
{
}
for(i=2;i<=23;i++)
{
}
}
void lucho()
{
int i;
clrscr();
for(i=2;i<=79;i++)
{
Funcin borde
Funcin borde

}
Funcin borde
for(i=2;i<=23;i++)
{
}
}
void main()
{
do
{
clrscr();
borde();
gotoxy(30,3);printf("<<ESTILOS DE BORDES>>");
gotoxy(5,5);printf("1.- Borde simple>>");
gotoxy(5,7);printf("2.- Borde doble>>");
Funcin borde
gotoxy(5,9);printf("3.- Encabezado y pie de pagina>>");
gotoxy(5,11);printf("4.- Borde <<Lucho's>>");
gotoxy(5,13);printf("5.- Salir>>");
do
{
gotoxy(5,15);printf("Que desea realizar>> ");scanf("%d",&op);
}
while(op>5);
switch(op)
{
case 1:
clrscr();
bsim();
gotoxy(30,10);printf("<<BORDE SIMPLE>>");
break;
case 2:
clrscr();
bdob();
gotoxy(30,10);printf("<<BORDE DOBLE>>");
Funcin borde
break;
case 3:
clrscr();
ep();
gotoxy(30,10);printf("<<ENCABEZADO Y PIE>>");
break;
case 4:
clrscr();
lucho();
gotoxy(30,10);printf("<>>");

break;
case 5:
exit(0);
break;
}
gotoxy(3,22);printf("PRESIONE 1 PARA VOLVER A REPETIR EL PROCESO O 0 PARA
FINALIZAR>> ");scanf("%d",&op);
}
while(op==1);
getch();
Corrido:
Programa 38
Disee un programa utilizando vectores y funciones que me permita ingresar datos a
un vector y presentarlos en otro vector
ANLISIS
Primero ingresamos las libreras que vamos a utilizar en este programa en este caso
son las dos principales la STDIO.H Y LA CONIO.H, despus como es un programa
con funciones declaramos la variable que vamos a utilizar globalmente.
Despus ingresamos una funcin con el nombre de borde para que nuestro
programa se visualice con un borde.
Luego realizamos el programa principal con un VOID MAIN () para que se abra el
programa principal seguido con la llave { y declaramos las dems variables a realizar
en el programa (int vector1[10],fila,op,lim;), despus ponemos un
do-while
para que se repita el programa n veces y llamamos las funciones realizadas y
realizamos el ingreso del lmite para que podaos ingresar datos a una funcin y que
luego se visualice.
CODIGO
#include<stdio.h>
Libreras que vamos a utilizar en el
#include<conio.h>
int i;
Declaramos
la
variable
global
void borde()
{
for(i=1;i<=80;i++)
{
Realizamos la funcin para que se
pueda realizar un borde en nuestro
for(i=1;i<=24;i++)
{
}
}

void main()
Realizamos el programa principal y declaramos la
variables que vamos a utilizar en el programa
int vector1[10],fila,op,lim;
do
{
clrscr();
Aqu damos un limite al
borde();
vector para poder dar datos
gotoxy(25,3); printf("**VISUALIZAR DATOS VECTOR**");
numricos a un limita vector
gotoxy(10,5); printf("INGRESE EL LIMITE==>");

scanf("%d",&lim);
Ingresamos
el
fila=6;
for(i=1;i<=lim;i++)
{
do
{
gotoxy(20,fila); printf(" ");
gotoxy(20,fila); scanf("%d",&vector1[i]);
Ingresamos los nmeros para que se

llene el vector previamente dado un
}
while(vector1[i]<3 || vector1[i]>23);
Damos o validamos los datos que estn entre 3 y
fila=fila+1;
}
fila=6;
for(i=1;i<=lim;i++)
{
Aqu se visualiza el vector

que ingresamos en otra
gotoxy(40,fila); printf("%d",vector1[i]);
fila=fila+1;
}
gotoxy(10,20); printf("PRESIONE 1 PARA REPETIR EL PROGRAMA CASO
CONTRARIO 0==>");
Ingresamos otra opcin para ver si se repite el programa n
scanf("%d",&op);

}
while(op);
Visualiza la opcin y da por terminado el
getch();
programa
CORRIDO
Programa 38
ENUNCIADO
Disee un programa utilizando vectores y un men de opciones que me permita
realizar las 4 operaciones bsicas, estas son: suma, resta, multiplicacin y divisin.
ANALISIS
En este programa se realizan las operaciones bsicas que son la suma, resta,
multiplicacin y divisin utilizando un men de opciones y con vectores, en donde
tenemos que ingresar valores en dos vectores diferentes en el vector1 y vector2
para que vayan realizando las operaciones correspondiente teniendo en cuenta las
condiciones plantedas que se dieron en la resta y divisin en donde el valor del
vector1 debe ser mayor al valor del vector2 si no se cumple la condicin no se
realiza las operaciones y se imprime un mensaje.
CDIFICACION
#include<stdio.h>
#include<conio.h>
Ingreso
libreras
las
#include<stdlib.h>
int multivec[15],opc,divisionvec[15],
restavec[15],i,op,col,fila,vector1[15],vector2[15],
Declaracin de
variables
sumavec[15],limite1;
void borde()
Funcin borde
{
for(i=1;i<=80;i++)
{
}
Este proceso es
para realizar el
borde

for(i=1;i<=24;i++)
{
}
}
Funcin para ingresar los valores
de los vectores
void ingreso(int limite1)

{
col=12;
fila=8;
Ingresamos la posicin en la cual

se va a visualizar los vectores
Utilizamos el for para poder
ingresar los valores del vector1 y
vector2 al final vamos sumando fila
para q vayan colocndose en las
posiciones correctas, cerramos la
laves del for y la llaves de la
funcin ingreso.
{
gotoxy(col,fila); scanf("%d",&vector1[i]);
gotoxy(col+10, fila); scanf("%d",&vector2[i]);
fila=fila+1;
}
}
void suma(int limite1)
Funcin para realizar la suma
Abrimos con una llave
fila=8;
Ingresamos el valor de la fila en la que va a

empezar a visualizarse los datos del vector.
{
sumavec[i]=vector1[i]+vector2[i];
gotoxy(40,fila); printf("%d",sumavec[i]);
fila=fila+1;

vector2, realizamos la operacin en
donde se suman los dos vectores e
imprimimos el resultado, vamos
sumando fila para las correctas
posiciones cerramos el for y la
funcin suma.

}
}
void resta(int limite1)
Funcin para realizar la resta
fila=8;

{
if(vector1[i]>=vector2[i])
{
restavec[i]=vector1[i]-vector2[i];
gotoxy(40,fila); printf("%d",restavec[i]);
}
else
{
gotoxy(40,fila); printf("NO SE PUEDE CALCULAR");
}
fila=fila+1;

ingresar los valores del
vector1 y vector2, luego se
utiliza un if para indicar que
el vector1 debe ser mayor
que el vector2 si la condicin
se cumple realizamos la
operacin en donde se resta
los valores del vector que
sea mayor e imprimimos el
resultado, cerramos el if y si
no se cumple la condicin
escribimos un mensaje y no
se realiza la operacin,
cerramos la llaves y vamos
sumando fila para las
correctas
posiciones
}
}
void multi(int limite1)
Funcin para realizar la multiplicacin
fila=8;


{
multivec[i]=vector1[i]*vector2[i];
gotoxy(40,fila); printf("%d",multivec[i]);
fila=fila+1;
}

vector2, realizamos la operacin en
donde se mulitiplican los dos
vectores e imprimimos el resultado,
vamos sumando fila para las
correctas posiciones cerramos el
for y la funcin multi.
}
void division(limite1)
Funcin para realizar la divisin.
fila=8;

{
if(vector1[i]>=vector2[i])
{
divisionvec[i]=vector1[i]/vector2[i];
gotoxy(40,fila); printf("%d",divisionvec[i]);
}
else
{
gotoxy(40,fila);
printf("NO SE PUEDE CALCULAR");
}
fila=fila+1;
}
}

ingresar los valores del
vector1 y vector2, luego se
utiliza un if para indicar que
el vector1 debe ser mayoro
igual que el vector2 si la
condicin
se
cumple
realizamos la operacin en
donde se dividen los valores
del vector que sea mayor e
imprimimos el resultado,
cerramos el if y si no se
cumple
la
condicin
escribimos un mensaje y no
se realiza la operacin,
cerramos la llaves y vamos
sumando fila para las
correctas
posiciones

void main()
Funcin principal del programa.
do
{
Utilizamos el ciclo do while para que el proceso se

repita tantas veces desee el usuario
clrscr();
Limpia la pantalla.
borde();
Llama a la funcin borde.
gotoxy(15,3); printf("**OPERACIONES CON VECTORES Y FUNCIONES**");

gotoxy(10,13); printf("QUE OPCION DESEA==>");
scanf("%d",&op);
switch(op)
{
case 1:
do
Utilizamos la sentencia
switch para el men de
opciones.
{
clrscr();
borde();
gotoxy(30,3);printf("1.-SUMA");
gotoxy(11,7); printf("VECTOR 1");
gotoxy(40,7); printf("SUMA VECTOR");
scanf("%d",&limite1);
Diseo de pantalla.

ingreso(limite1);
suma(limite1);
gotoxy(10,23);
printf("SI DESEA REPETIR EL
PROCESO PRESIONE 1 CASO
CONTRARIO 0==>");
scanf("%d",&opc);
}
while(opc==1);
break;
case 2:
do
{
clrscr();
borde();
gotoxy(40,7); printf("RESTA VECTOR");
ingreso(limite1);
resta(limite1);
gotoxy(10,23); printf("SI DESEA REPETIR
EL PROCESO PRESIONE 1 CASO CONTRARIO 0==>");
scanf("%d",&opc);
}
Diseo de la segunda
opcin del men de
opciones llamamos a las
funcione y utilizamos el
ciclo do while pa repetir el
proceso la veces que
desee el usuario, lo

while(opc==1);
break;
case 3:
do
{
clrscr();
borde();
Diseo de la tercera
opcin del men de
proceso la veces que
desee el usuario, lo

gotoxy(40,7); printf("MULTIPLICACION VECTOR");
ingreso(limite1);
multi(limite1);
gotoxy(10,23); printf("SI DESEA REPETIR EL PROCESO PRESIONE 1 CASO
CONTRARIO 0==>");
scanf("%d",&opc);
}
while(opc==1);
break;
do
{
case 4:
clrscr();
borde();
Diseo de la cuarta
opcin del men de

gotoxy(40,7); printf("DIVISION VECTOR");
ingreso(limite1);
division(limite1);
gotoxy(10,23); printf("SI DESEA REPETIR
EL PROCESO PRESIONE 1 CASO CONTRARIO 0==>");
scanf("%d",&opc);
}
while(opc==1);
break;
}
clrscr();
borde();
Cerramos
el
switch
limpiamos
pantalla
y
volvemos a llamar a la
funcin borde.
gotoxy(10,23);
printf("SI DESEA VOLVER AL MENU PRESIONE 1 CASO CONTRARIO O==>");
scanf("%d",&op);
}
Cerramos el ciclo do while

escribiendo un mensaje
while(op==1);
getch();
Pausa.
}
Cerramos la funcin main.
CORRIDO
Programa 39
Enunciado
Disee un programa utilizando vectores y funciones que me permita validar los datos de entrada de
un vector y presentarlos en un vector resultante
Anlisis
Ingresar el vector de entrada
Visualizar en un nuevo vector los vectores de entrada
Cdigo
#include<stdio.h>
#include<conio.h>
Liberia principal
int vector1[100],fila=10, i,lim;
void borde()
Declaracion de variables globales
Inicio de funcion
{
for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)
{
}
}
proceso para realizer el borde

void entrada() Inicio de la funcin
{
gotoxy(23,8);printf("Ingreso:");
Mensaje en la pantalla
gotoxy(20,6);printf("Ingrese el limite:");scanf("%d",&lim); Ingresar la variable

for(i=1;i<=lim;i++)
{
Inicio de lazo for
do
{
inicio de un lazo do para que genere n veces
gotoxy(25,fila);printf(" "); recorrido de espacio

gotoxy(25,fila);scanf("%d",&vector1[i]);
leer la variable
}while(vector1[i]<3||vector1[i]>23); cierre de validacion datos
fila=fila+1;
}
Cierre de lazo for
Fin de la funcin
void salida()
{
Inicio de la funcin
fila=10;
gotoxy(57,8);printf("Salida:");
for(i=1;i<=lim;i++)
Inicio de un lazo for de un limite dado hasta un limite dado
{
gotoxy(60,fila);printf("%d",vector1[i]);
fila=fila+1;
}
Cierre de lazo for
cierre de la funcion
main()
Inicio de programa principal
Impremir el resultado

{
clrscr();
Blanqueado de pantalla
borde();
Llamada de la funcin de borde
gotoxy(31,4);printf("PRESENTACION DE VECTORES");
entrada();
salida();
getch();
}
Corrido
Llamada de la funciones
pausa en la pantalla
Fin de programa principal
Programa 40
Enunciado
Disee un programa utiliza do vectores y funciones que me permita sumar los datos ingresados y
validados de un vector y presentar la sumatoria en un vector resultante.
Anlisis
Ingresar los datos y validar de un vector
Representar la sumatoria en un nuevo vector
Cdigo
#include<stdio.h>
Librera s principales
#include<conio.h>
int vector1[15],vector2[15],sumavector[15],fila=10,lim,i,col=20,op;
globales
void borde()
{
Inicio de la funcion
for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)
{
}
}
proceso para realizer el borde
declareacion devariables
void ingreso(int limite1) Inicio de la funcion

{
for(i=1;i<=limite1;i++) Inicio de un lazo for
{
gotoxy(col,fila);scanf("%d",&vector1[i]);
leer la variable
gotoxy(col+10,fila);scanf("%d",&vector2[i]);
fila=fila+1;
posiciones en la pantalla
Cierre de lazo for
Cierre la llave de funcion
void suma(int limites) Inicio de a funcion

{
fila=10;
Posicion en la pantalla
gotoxy(50,8);printf("vector resultante");
for(i=1;i<=limites;i++)
Inicio de un lazo for
{
sumavector[i]=vector1[i]+vector2[i];
gotoxy(60,fila);printf("%d",sumavector[i]);
fila=fila+1;
formula para realizar la suma

Imprimir el resultado
posicion en la pantalla
Cierre de lazo for
Cierre de la funcion
main()
{
Do
{
fila=10;
inicio de lazo do para la validacion de datos

clrscr();
Blanqueado de pantalla
borde();
Llamada de la funcin
gotoxy(31,4);printf("SUMA DE VECTORES");
gotoxy(15,8);printf("vector 1:");
gotoxy(27,8);printf("vector 2:");
gotoxy(22,6);printf("Ingrese el limite:");scanf("%d",&lim); Leer la variable
ingreso(lim);
suma(lim);
Llamada de la funciones
getch();
Pausa en la pantalla
gotoxy(10,22);printf("Desea realizar otra suma 1, salir 0>> ");scanf("%d",&op);Leer la variable

}while(op==1); Cierre de lazo for de validacin de datos
}
Corrido
Fin de programa principal
Programa 42
Disee un programa utilizando funciones que me permita ingresar n nmeros en un vector entre 6 y
26, recorra el vector y encuentre todas las posiciones pares y asgnelas a un nuevo vector, recorra el
vector original y encuentre todas las posiciones impares del vector y asgnelos a un nuevo vector,
visualice el vector de entrada y los vectores resultantes.
ANALISIS:
Nos pedir ingresar un lmite de datos y al frente nos debe imprimir en un vector los datos de las
posiciones pares y en otro vector nos imprimir los datos de las posiciones impares. Como as
tambin nos genera un borde como diseo del programa, y como final tenemos ingresar uno para
continuar utilizando nuestro programa o 0 para salir del mismo.
CODIFICADO:
#include<conio.h>
Activacin de librera esto
#include<stdio.h>
habilita procesos para el
#include<stdlib.h>
int i, j=1, f, vect[10], vectpar[10], vectimp[10], op, l;
void bdob()
{
int i;
programa
Declaracin de
variables que se
utilizaran en el
programa
Funcin borde
clrscr();
gotoxy(1,1);printf("*");
Generacin del borde
for(i=2;i<=79;i++)
utilizando posiciones e
imprimiendo el borde
}
for(i=2;i<=23;i++)
{
que va a ir en pantalla

}
}
void par()
{
j=1;
for(i=1;i<=l;i++)
{
if(i%2==0)
{
vectpar[j]=vect[i];
j=j+1;
}
Proceso de comparacin si
la posicin es par y se
almacenara en un nuevo
vector y se imprimir en
pantalla utilizaremos el
gotoxy para posiciones en
}
f=10;
for(i=1;i<j;i++)
{
gotoxy(39,f);printf("%d",vectpar[i]);
f=f+1;
}
}
void impar()
{
Funcin para ver si la posicin es

impar
j=1;
for(i=1;i<=l;i++)
{
Comparacin si la funcin es
impar
if(i%2==1)
{
vectimp[j]=vect[i];
j=j+1;
}
Almacenamiento en un nuevo
vector

}
f=10;
for(i=1;i<j;i++)
{
gotoxy(60,f);printf("%d",vectimp[i]);
f=f+1;
Impresin de datos de las

posiciones impares
}
}
void main()
Programa principal
{
do
{
flushall();
f=10;
clrscr();
bdob();
Do while este nos ayuda a

utilizar el programa cuantas
veces deseemos
Limpia pantalla
Llama a la funcin del
gotoxy(36,3);printf("VECTORES");
gotoxy(5,5);printf("Ingrese el limite>> ");scanf("%d",&l);
gotoxy(15,8);printf("VECTOR 1");
Pide ingresar un limite de

generacin de datos
gotoxy(29,8);printf("POSICIONES IMPAR");
gotoxy(51,8);printf("POSICIONES PAR");
for(i=1;i<=l;i++)
{
gotoxy(3,f);printf("INGRESO %d::",i);
do
Ingreso de datos del

vector
{
gotoxy(20,f);printf(" ");
gotoxy(20,f);scanf("%d",&vect[i]);
}
while(vect[i]<6 || vect[i]>26);
f=f+1;
Validacin de los datos,

estos deben ser mayor que
seis y menor que veinte y

}
par();
impar();
Llama a la funcin par

Llama a la funcin
gotoxy(3,22);printf("PRESIONE 1 PARA CONTINUAR O 0CASO CONTRARIO::> ");scanf("%d",&op);

}
while(op==1);
Cierre del do while
getch();
}
CORRIDO:
Cierre o fin del
Programa 43
Disee un programa utilizando funciones y vectores que me permita generar un vector de posiciones
pares con la serie del fibonasi y las posiciones impares con el factorial.
ANALISIS:
Nos pedir ingresar un limite de datos con ello nos generara internamente el fibonaci y factoreal y
nos imprimir las posiciones impares con el fibonaci y las posiciones pares con el factoreal.
CODIFICADO:
#include<conio.h>
#include<stdio.h>
int i,n,op,a,b,c,vect[25],fi;
LIBRERIAS QUE HABILITAN
PROCESOS PARA LA ELABORACION

DEL PROGRAMA.
float f;
void borde()
{
for(i=1;i<=79;i++)
{
ELABORACION DE UN BORDE PARA

DISEO DE PANTALLA UTILIZANDO
POSICIONES.
}
for(i=2;i<=23;i++)
{
}
}
void serie(int m)
{
a=1;
FUNCION SERIE DONDE

GENERARA EL FIBONACI Y EL
IGUALACION DE VARIABLE. DESDE
QUE NUMERO DESEAMOS QUE
EMPIESE

b=0;
f=1;
gotoxy(9,6);printf("FIBONACI
FACTOREAL");
for(i=1;i<=m;i++)
IMPRIMIRA LOS MENSAJES QUE

DESEEMOS
{
f=f*i;
REALIZARA OPERACIONES PARA

CALCULAR FIBONACI Y
c=a+b;
a=b;
b=c;
gotoxy(15,8+i);printf("%d",c);
gotoxy(25,8+i);printf("%0.0f",f);
IMPRIMIRA LOS RESULTADOS

DE FIBONACI Y FACTOREAL
if(i%2==0)
{
vect[i]=c;
}
COMPRUEBA SI LA POSICION ES
PAR O IMPAR
else
{
vect[i]=f;
}
}
fi=9;
gotoxy(40,6);printf("POSICION");
for(i=1;i<=m;i++)
{
gotoxy(45,fi);printf("%d",vect[i]);
fi=fi+1;
}
}
void main()
PROGRAMA PRINCIPAL
{
do
CICLO DO WHILE ESTE

AYUDARA A REGRESAR AL
PROGRAMA CUANTAS VECES

{
clrscr();
borde();
gotoxy(30,2);printf("... SERIE CON VECTORES ...");
gotoxy(10,4);printf("LIMITE::> ");scanf("%d",&n);
LLAMAMOS A LA FUNCION
DEL BORDE
INGRESAREMOS UN LMITE
serie(n);
gotoxy(15,22);printf("DESEA CONTINUAR DIJITE 1 CASO CONTRARIO 0 ==> ");scanf("%d",&op);
}while(op==1);
getch();
}
CIERRE O FIN DEL

PROGRAMA
CORIIDO:
Programa 44
1.- Enunciado:
Disee un programa utilizando funciones y vectores que me permita ingresa n
elementos en un vector entre 3 y 33, recorre el vector y encontrar todos los datos

pares y asignarlos a un nuevo vector, encontrar todos los datos impares y asignarlos
a un nuevo vector, visualice tanto el vector de entrada como los vectores resultantes.
2.-Codicifcado:
#include<conio.h>
Libreras principales
#include<stdio.h>
int i, f, vect[100], vectbusq[100], lim, op;
Variables Globales
void bdob()
{
int i;
clrscr();
textcolor(i);gotoxy(1,1);cprintf("");
gotoxy(80,1);cprintf("");
for(i=2;i<=79;i++)
{
textcolor(i);
Nuestro
Borde
acompaado de una
Funcin.
gotoxy(i,1);cprintf("");
gotoxy(i,24);cprintf("");
}
gotoxy(1,24);cprintf("");gotoxy(80,24);cprintf("");
for(i=2;i<=23;i++)
{
textcolor(i);
gotoxy(1,i);cprintf("");gotoxy(80,i);cprintf("");
}
}
void busq(int l)
Funcin donde realizaremos el proceso del ejercicio
Abrimos llave para nuestra Funcin.
Igualacin de variables
f=9;
for(i=1;i<=l;i++)
Este for nos indica el lmite y
abrimos la llave del primer for.
if(vect[i]%2==0)
Dentro del for realizamos un if

donde nos indica si la divisin es
igual a cero es para el nmero
par, e imprimimos en un nuevo
vector el resultado en caso que
sea nmero par.
{
gotoxy(34,f);printf("%d",vect[i]);
f=f+1;
}
}
Cerramos la llave del primer for
f=9;
Igualacin de la variable
for(i=1;i<=l;i++)
{
Este es un segundo for nos indica el lmite

y abrimos llave para inicializar el for.
if(vect[i]%2==1)
{
gotoxy(55,f);printf("%d",vect[i]);
f=f+1;
}
}
}
void main()
{
Dentro
del
segundo
for
realizamos un if donde nos
indica si el residuo de la divisin
es 1 su respuesta es impar,
abrimos llaves e imprimimos el
resultado impar en un nuevo
vector, y cerramos las llaves del
for como del if y de la funcin.
Comenzaremos con el programa principal.

do
{
Abrimos la sentencia.
clrscr();
Limpiar pantalla.
bdob();
Llamamos a la funcin borde.
gotoxy(21,3);printf("<<BUSQUEDA DE # PARES E IMPARES_VECTORES>>");

gotoxy(5,5);printf("Ingrese el limite>> ");scanf("%d",&lim);
gotoxy(13,7);printf("<<VECTOR>>");
gotoxy(26,7);printf("<<NUMEROS PARES>>");
gotoxy(47,7);printf("<<NUMEROS IMPARES>>");
Impresin de mensajes
f=9;
Posicin de fila
for(i=1;i<=lim;i++)
Este for nos indica el lmite e abrimos
{
do
{
Este es un Do While interno nos indica que

imprimiremos la respuesta e ingresamos el
vector, el While nos indica si l un vector
es menor que 3 o mayor que 33.
while(vect[i]<3 || vect[i]>33);
Declaramos la posicin de fila.
f=f+1;
Cerramos llave
gotoxy(18,f);scanf("%d",&vect[i]);
busq(lim);
Llamamos
funcin
la

gotoxy(3,22);printf("Presione 1 para volver a ingresar vectores o 0 para finalizar>>
");scanf("%d",&op);
Imprimimos el mensaje
}
while(op==1);
getch();
}
Aqu cerramos la llave del ciclo do while

damos pause a nuestro programa y cerramos
llave.
3.- Anlisis del programa:
Primero ingresamos las libreras las cuales son muy importantes.

Luego realizamos un for donde nos permite hacer el borde de nuestro
programa.
Realizamos una funcin en la cual hacemos el proceso de los nmeros pares
e impares con vectores.
Para finalizar abrimos la funcin principal donde llamamos a las dems
funciones para que se realice el proceso y asi finalizamos nuestro programa,
y obtenemos lo que deseamos.
4.-Corrido del Programa:
Programa 45
Disee un programa en c utilizando vectores y funciones que me permita generar con cualquier
factor impar ingresado desde teclado las posiciones pares del vector, y con um factor par las
posiciones impares del vector.
Libreras

#include<stdio.h>
#include<conio.h>
int j,fila,vecfi[10],i,f1,f2,limite,facpar,facimp,op;
void borde()
{
for(i=1;i<=24;i++)
{
gotoxy(2,i);printf("-");
}
for(i=1;i<=80;i++)
{
}
}
void factor()
{
fila=10;
int limitetab;
limitetab=0;
for (j=1;j<=limite;j++)
{
if(j%2!=0)
{
limitetab=limitetab+1;
vecfi[i]=facpar*limitetab;
gotoxy(10,fila);printf("%d",vecfi[i]);
fila=fila+1;
}
else
{
vecfi[i]=facimp*limitetab;
gotoxy(10,fila);printf("%d",vecfi[i]);
fila=fila+1;
}
}
}
void main()
{
do
{
clrscr();
borde();
gotoxy(8,4);printf("Ingrese el limite: "); scanf("%d",&limite);
do
{
gotoxy(5,6); printf(" ");
gotoxy(5,6);printf("par:");scanf("%d",&facpar);
}
while(facpar%2==1);
Funcin global para el

borde, e inicio del ciclo, da
color
Inicio de la funcin
factor y del ciclo for
Condicin para calcular los

factores impares y pares
Inicio del programa

principal
Inicio de el ciclo do while
llamamos al borde ye
ingresamos el limite
Ingreso de los
nmeros pares

do
{
gotoxy(5,7); printf(" ");
gotoxy(5,7);printf("impar: ");scanf("%d",&facimp);
}
while(facimp%2==0);
factor();
gotoxy(3,22); printf("nuevo proceso 1 salir 0: "); scanf("%d",&op);
}
while(op==1);
getch();
}
Ingreso de los impares,

repeticin del proceso y
fin del programa
Programa 46
Disee un programa utlizando vectores y funciones que me permita ordenar un vector en forma
ascendente y descendente. Ingresado entre 6 y 26.
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
Libreras, declaracin de
variables he inicio de la
funcin borde

int i,conta,residuo,j,op,fila=5,k,aux,limite,vec[10];
void borde()
{
for(i=1;i<=79;i++)
{
}
for(i=1;i<=23;i++)
{
}
}
void ingreso()
{
int fila=5;
for(i=1;i<=limite;i++)
{
do
{
gotoxy(5,fila);printf(" ");
gotoxy(5,fila);scanf("%d",&vec[i]);
}
while((vec[i]<6)||(vec[i]>26));
fila=fila+1;
}
}
void ascendente ()
{
int fila=5;
for (i=1;i<=limite;i++)
{
{
if (vec[i]<vec[j])
{
aux=vec[i];
vec[i]=vec[j];
vec[j]=aux;
}
}
}
{
gotoxy(40,fila);printf("%d",vec[i]);
fila=fila+1;
}
}
void descendente ()
{
Proceso de borde
Inicio de la funcin para

el ingreso con un rango
entre 6 y 26
Inicio de funcin
ascendente calculamos
con dos for y una
condicin Y para la
impresin un for mas
para el vector
Inicio de funcin
descendente calculamos
con dos for

int fila=5;
{
{
if (vec[i]>vec[j])
{
aux=vec[i];
vec[i]=vec[j];
vec[j]=aux;
}
Usamos una
}
condicin Y
}
para la
{
impresin un
for mas para el
fila=fila+1;
}
}
void main()
{
do
{
clrscr();
borde();
gotoxy(3,2);printf("ingrese el limite....: ");scanf("%d",&limite);
gotoxy(2,4);printf("INGRESO");
gotoxy(30,4);printf(" ASCENDENTE DESCENDENTE");
ingreso();
ascendente();
descendente();
gotoxy(3,22);printf("pulse 1 para volver y salir 0.....: ");scanf("%d",&op);
}
while (op==1);
getch();
}
Inicio del
programa
principal
llamamos
funciones he
ingresamos el
limite
Programa 46
ENUNCIADO
Disee un programa utilizando vectores y funciones que me permita generar un vector de n

elementos con un factor ingresado desde teclado en las posiciones impares del vector y

factorial en las posiciones pares del vector presente en el vector ordenado en forma
ascendente y descendente
CODIFICACION
Ingreso
las
libreras
#include<stdio.h>
#include<conio.h>
Declaracin
de
variables
int op,i,j,limite,au,aux,mu,factor,fa,fila,vecto[15];
void borde()
Funcin borde
{
for(i=1;i<=80;i++)
{
Este proceso es
para realizar el
borde
for(i=1;i<=24;i++)
{
}
}
Funcin
de
la
serie
Igualacin de las
variables
void facto()
{

fila=9;
mu=0;
au=1;
factor=1;
Que el for vaya
{
hasta el lmite
if(i%2==1)
{
mu=mu+fa;
vecto[i]=mu;
En este proceso es para
que podamos sacar los
else
nmeros
donde
impares
el
nmero
ingresado lo dividimos
factor=factor*au;
para
au=au+1;
sino
caso
contrario sacamos el
factor y despus vamos
vecto[i]=factor;
a imprimir el vector [i]
donde despus vamos a
gotoxy(7,fila);printf("%d",vecto[i]);
fila=fila+1;
}
}
Ingresamos
una
void orden()
nueva funcin que

se llama orden

{
for(j=1;j<=limite;j++)
{
if(vecto[i]<vecto[j])
{
Este
proceso
nos
sirve para ordenar el
vector
en
forma
ascendente vamos a
mandar dos for uno
que es interno y otro
que
es
donde
vector
despus
a
vecto[j]=aux;
[i]sea menor que el

vamos
vecto[i]=vecto[j];
externo
el
vector[j]
aux=vecto[i];
mandar
otro for que vaya
fila=9;
{
fila=fila+1;
}
fila=9;
Este
proceso
nos
sirve para ordenar el

vector
en
forma
ascendente vamos a
mandar dos for uno
que es interno y otro

que
donde
es
externo
el
vector
[i]sea mayor que el
{
{
if(vecto[i]>vecto[j])
{
aux=vecto[i];
vecto[i]=vecto[j];
vecto[j]=aux;

}
}
}
fila=9;
Despus
vamos
mandar otro for que
vaya hasta el lmite y
despus
vamos
imprimir el vector [i]
fila=fila+1;
}
}
Abro el programa
void main()
{
Abro el do
do
{
Limpio de pantalla
Llama a la funcin
clrscr();
borde();
de borde
Posicin en donde
gotoxy(25,3);printf("FacPares/Impares");
que quiero que se

me imprima printf
gotoxy(12,5);printf("Ingrese el limite: ");scanf("%d",&limite);
Pide el lmite que
quieres imprimir
Pide el factor que
gotoxy(10,7);printf("Factor: ");scanf("%d",&fa);
quieres imprimir
Llamo a la funcin
facto();
facto
Llamo a la funcin
orden
orden();
Se me imprime
mensaje
para
continuar o terminar
el programa
Cierro la funcin
}
while(op==1);
de do-while
Cierro
gotoxy(5,20);printf("Presione 1 para repetir el proceso o 0

para salir: ");scanf("%d",&op);
el
programa
getch();
}
CORRIDO
ANALISIS
En este programa presentado, vamos a trabajar con funciones y vectores donde tenemos
que la posiciones impares se me ubique el nmero ingresado y el factorial tiene que ubicarse
en las posiciones pares del vector donde despus vamos a ordenar el vector en orden
ascendente y en orden de
z

se utilizara para la opcin desea continuar SI o NO, esto se lo realiza con el Laso DO WHILE
que permite generar nuevamente el programa.
PROGRAMA 48
ENUNCIADO

Disee un programa con funciones y vectores que me permita ingresar un sin
nmero de elementos en un vector entre 3 y 25, recorrer el vector y encontr
todos aquellos valores que sean nmeros primos asgnelos en un nuevo
vector y presntelos ordenados en forma ascendente y descendente.
ANLISIS
Para realizar este programa necesitamos utilizar funciones tanto para el borde como
para los nmeros primos y para ordenar dichos nmeros en forma ascendente y
descendente.
Para el vector que vamos a ingresar necesitamos un ciclo do while el mismo
que debemos condicionarlo para que este vector ingresado sea menor que 3
o mayor que 25, este proceso debemos realizarlo dentro de una funcin a la
cual denominaremos pri ya que tambin dentro de esta funcin realizaremos
las operaciones para encontrar los nmeros primos para lo cual necesitamos
de la condicin if y de ciclos for los cuales nos ayudaran a generar dichos
nmeros.
Par ordenar el vector de forma ascendente y descendente necesitamos de
una funcin denominada as para la forma ascendente y de una funcin
denominada des para la forma descendente dentro de las cuales se
encontrara un ciclo for el mismo que nos ayudara a realizar dicho proceso e
imprimirlo tanto ascendente como descendente.
Adems utilizamos un ciclo do while para repetir este proceso el nmero de
veces que el usuario desee.
.
DOCUMENTACIN
#include<conio.h>
Ingresamos las libreras que vamos a
#include<stdio.h>
int f1, aux, num, i, j, f, vect[100];
Ingresamos las variables que vamos a utilizar, son
int vectser[100], lim, op, cont;
variable de tipo enteras
void borde()
{
int i;
clrscr();
for(i=2;i<=79;i++)

{
Aqu realizamos una funcin para
poder realizar el borde en el
programa
}
for(i=2;i<=23;i++)
{
}}
void primo(int l)
{
Aqu realizamos una funcin para
f=9;
poder verificar si un nmero es o no
f1=9;
for(j=1;j<=l;j++)
{
do
{
Aqu imprimimos y validamos el vector ingresado que
este entre parmetro que nos dieron para realizarlo
gotoxy(18,f);scanf("%d",&vect[j]);
}
while(vect[j]<3 || vect[j]>25);
Sumamos a la fila (f=f+1), y igualamos a cero el
f=f+1;
cont=0;
for(i=1;i<=vect[j];i++)
{
Este for es para que se imprima en las filas
if(vect[j]%i==0)
{
cont=cont+1;
}}
if(cont==2)
{
Este if es para que se imprima en las filas
vectser[j]=vect[j];
gotoxy(34,f1);printf("%d",vectser[j]);
f1=f1+1;
}}}
void orden(int l)
Esta funcin es para poder ordenar al vector de manera ascendente y
{
descendente
for(i=1;i<=l;i++)
Realizamos dos for para que se de un lmite y se pregunte a las dos
{
posiciones, y despus de le pregunta con un if si el vector [i] es < que el
for(j=1;j<=l;j++)
{

if(vectser[i]<vectser[j])
{
aux=vectser[i];
Aqu utilizamos una variable auxiliar
vectser[i]=vectser[j];
para que tome el valor de otra
vectser[j]=aux;
}}}
gotoxy(29,9);printf("ASCE");
f=11;
Igualamos la fila a
for(i=1;i<=l;i++)
11
{
gotoxy(39,f);printf("%d",vectser[i]);
Imprimimos al vector
f=f+1;
ascendente
}
for(i=1;i<=l;i++)
Estos for son para que se
{
de
manera
imprima hasta un cierto lmite.

for(j=1;j<=l;j++)
{
if(vectser[i]>vectser[j])
{
aux=vectser[i];
Aqu utilizamos una variable auxiliar
vectser[i]=vectser[j];
para que tome el valor de otra
vectser[j]=aux;
}}}
gotoxy(52,9);printf("DESC");
Imprimimos al vector de manera
f=11;
descendente
for(i=1;i<=l;i++)
{
gotoxy(62,f);printf("%d",vectser[i]);
f=f+1;
}}
Realizamos
el
programa
void main()
principal
{
do
Ponemos una sentencia do-while para que se pueda repetir n
{
veces.
clrscr();
borde();
Ingresamos el
gotoxy(21,3);printf("BUSQUEDA DE NUMRS- PARES E IMPARES");
gotoxy(5,5);printf("limite: ");scanf("%d",&lim);
lmite
e
gotoxy(13,7);printf("VECTOR");
imprimimos un
gotoxy(26,7);printf("#PRIMOS");
ttulo
gotoxy(47,7);printf("#IMPARES");
primo(lim);
Llamamos a las dems funciones que ya
orden(lim);

gotoxy(3,22);printf("Otra vez si1/no 0: ");scanf("%d",&op);
}
while(op==1);
getch();
Terminamos con un getch(); y con la
}
Cerramos el lazo do-
CORRIDO DEL PROGRAMA
PROGRAMA 49
ENUNCIADO
Disee un programa utilizando funciones que me permita leer una cadena de
caracteres ingresado desde teclado y que a su vez cuente la cantidad de caracteres
de dicho vector.
ANLISIS
En este programa por medio de funciones podemos realizar tanto el borde como
para colocar la cadena de caracteres e imprimirla y para encontrar los datos de las
posiciones impares del vector.
Para colocar la cadena de caracteres en una posicin e imprimirla
necesitamos de una funcin a la cual la denominaremos void cad para
realizar dicho proceso requerimos de un ciclo for el mismo que nos permitir
imprimir la cadena de caracteres deseada y aadirle color.
Para encontrar los datos de la cadena de caracteres del vector necesitamos
de una nueva funcin a la cual la denominaremos void cont para realizar
dicho proceso requerimos de un ciclo for el cual nos permitir contar los
caracteres ingresados adems requerimos de otro ciclo for el mismo que nos
ayudara a imprimir dichos datos.
Adems utilizamos un ciclo do while para repetir este proceso el nmero de
veces que el usuario desee.
DOCUMENTACIN
#include<stdio.h>
#include<conio.h>
Libreras
#include<string.h>
#include<ctype.h>
char cadena[20],vecimpar[20];
Declaracion de variables tipo
int i,fi,op,n,h;
Declaracion de variables
void borde()
Inicio funcin borde
{
for (i=1;i<=80;i++)
Inicio ciclo for
{
textcolor(i+1);
color
Impresin borde
}
Fin ciclo for
for (i=1;i<=24;i++)
Inicio ciclo
{
textcolor(i+1);
color
Impresin borde
Fin ciclo for

}
}
Fin funcin borde
void cad()
Inicio funcin cad
{
flushall();
Palabra reservada que permite funcionar ciclo do
gotoxy(30,5);gets(cadena);
Impresin
l=strlen(cadena);
Igualacin limite palabra reservada
fila=9;
Igualacin fila a 9
for(i=0;i<l;i++)
Inicio ciclo for
{
textcolor(i+1);
color
gotoxy(23,fi);cprintf("%c",cadena[i]);
Impresin
vector
fila=fila+1;
Contador mas 1
}
Fin ciclo for
}
Fin funcin cadena
void cont()
Inicio funcin cont
{
h=1;
Igualacin variable a 1
for(i=0;i<n;i++)
Inicio ciclo
{
vecimpar[h]=cadena[i];
Igualacin vector auxiliar a vector
h=h+1;
ingresante
Contador mas 1
}
Fin ciclo for
fila=8;
Igualacin variable fila a
for(i=0;i<h;i++)
8Inicio ciclo
{
gotoxy(45,fi);printf("%c",vecimpar[i]);
fila=fila+1;
Contador mas 1Impresin vector resultante
}
Fin ciclo for
}
Fin
funcion
void main()
Inicio funcin principal
{
do
Inicio ciclo do
{
clrscr();
Blanqueo
de
borde();
pantalla
Se llama a>>");
la funcion borde
gotoxy(25,3);printf("<< CARACTERES
gotoxy(8,5);printf("*.CARACTERES : ");
Impresin titulos
gotoxy(15,7);printf("<< V REALIZADO>>");
gotoxy(38,7);printf("<< V.RESULTANTE>>");
cad();
Se llama a la funcion
cont();
Se llama a la funcin cont
gotoxy(12,22);printf("PULSE 1 PARA CONTINUAR O 0 PARA SALIR : ");scanf("%d",&op);
Impresin
repeticin

}
while(op==1);
getch();
}
Fin
ciclo
do
Fin
programa
Programa 50
Disee un programa en c++ utilizando funciones que me permita leer una cadena de caracteres,
ingresar desde teclado un caracter que desee buscar en la cadena ingresada, asignela a un nuevo
vector e imprimalo en un vector resultante.

#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<ctype.h>
char nombre[20],a;
int i,fi,n,op, cont;
void borde()
{
for(i=1;i<=79;i++)
{
textcolor(17);
}
for(i=2;i<=23;i++)
{
textcolor(17);
Abrimos las
Iniciamos los valores de nuestro programa
For para ingresar el vector,

utilizamos la funcin textcolor
para poner color a las letras
Nuestro borde
}
}
Funcin que
void nomb()
ocuparemos despus
{
flushall();
Permite leer el carcter
gotoxy(12,5);gets(nombre);
n=strlen(nombre);
Permite almacenar en otro
fi=5;
for(i=0;i<n;i++)
{
if(islower (nombre[i]))
{
For para ingresar el vector,
nombre[i]=toupper(nombre[i]);
utilizamos la funcin textcolor
textcolor(i+1);
gotoxy(40,fi);cprintf("%c",nombre[i]);
para poner color a las letras
fi=fi+1;
}
if(nombre[i]==a)
{
cont=cont+1;
textcolor (3);
gotoxy(30,10);cprintf("Letras>> %d",cont);
}}
Comenzaremos con el
}
void main()
programa principal
{
do
Abrimos la Sentencia
{
do
Borrado de pantalla y llamado de la funcin
borde
Llamamos a las funciones
clrscr();
borde();
nomb();
textcolor(2);
Imprimir el ttulo y
gotoxy(12,18);cprintf("ingrese el caracter ");scanf("%c",&a);
subttulos de nuestro
textcolor(3);
for(i=0;i<n;i++)
{
if(nombre[i]==a)
For para su limite y el if para
{
buscar su posicin par
cont=cont+1;
}}
textcolor (3);
gotoxy(15,15);cprintf("Letras>> %d",cont);
gotoxy(12,22);cprintf("desea repetir 1 salir 0: ");scanf("%d",&op);
}while(op==1);
getch();
Pausado en el programa y
}
cerrado del programa
Cerramos la sentencia do
while
ANALISIS:
Primero empezamos abriendo nuestras bibliotecas

Despus validamos nuestras variables globales, que servirn para la
ejecucin de nuestro programa, teniendo en cuenta que estamos
ocupando char que servir para hacer cadena de caracteres.
Realizamos nuestra primera funcin llamada borde que nos servir para
ms despus abrir en nuestras funciones realizadas
Comenzamos a realizar nuestra primera funcin llamada nomb, en esta se
guardaran todos los procesos para poder hacer nuestro primer programa
donde est el ingreso y las etiquetas de nuestro programa, adems
ingresaremos el carcter y un proceso de for en el cual se almacenen un
vector con sus respectivos caracteres.
Despus de esto comenzaremos otra funcin llamado impar, en la cual
haremos todos los procesos respectivos a nuestro segundo programa el
cual ira comparando las posiciones impares de nuestro vector anterior y
ahora irlo almacenando en un vector nuevo.
Por ultimo realizaremos nuestro programa principal en el cual solo
llamaremos a nuestras anteriores funciones en las cuales se han guardado
todos los procesos de cada programa, llamaremos a nuestro borde i
limpiado de pantalla
Por ultimo haremos que se repita nuestro programa con una sentencia do
while y cerraremos nuestro programa.
CORRIDO DEL PROGRAMA:
programa51
.- Disee un programa utilizando funciones y vectores que me permita leer una
cadena de caracteres, leer el vector y encontrar todos los datos que se encuentren
en posicin de impares del vector y asignarlos a un nuevo vector, presente el nuevo
vector ordenado.
Empezamos abriendo las libreras para activar funciones, utilizamos variables de

tipo enteras y alfabticas tres funciones con sentencia for, una para el borde y
las dos restantes para realizar los procesos y al impresin de las letras qu
estn en las posiciones impares, un do-while para repetir los procesos cuantas
veces se desee, empezamos el programa con viod main, llamamos a las
funciones, e imprimimos resultados.
DOCUMENTACION
#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<ctype.h>
char nombre[20],vecimpar[20];
int i,fi,op,n,h;
void borde()
{
for(i=1;i<=79;i++)
{
textcolor(9);
}
for(i=2;i<=23;i++)
{
textcolor(9);
}
}
void nomb()
{
flushall();
textcolor(3);
gotoxy(5,5);cprintf("TEXTO:");
textcolor(i+1);
gotoxy(12,5);gets(nombre);
n=strlen(nombre);
Libreras.- coleccin de clases y funciones,

escritas en el ncleo del lenguaje.
Variables.- son un tipo de
datos, Alfabticas y

realizar el borde
Funciones.- Las funciones son bloques de cdigo

utilizados para dividir un programa en partes ms
pequeas
Color para el texto
Lectura de variables

fi=9;
for(i=0;i<n;i++)
Un vector, tambin llamado array(arreglo)
{
unidimensional, es una estructura de datos que
textcolor(3);
permite agrupar elementos del mismo tipo y
gotoxy(5,7);cprintf("VECTOR");
almacenarlos en un solo bloque de memoria
textcolor(i+1);
juntos, uno despus de otro.
gotoxy(8,fi);cprintf("%c",nombre[i]);
fi=fi+1;
}
}
void impar()
{
h=1;
for(i=0;i<n;i++)
{
if(i%2==0)
{
vecimpar[h]=nombre[i];
h=h+1;
}
S

impresin de las
}
letras en posiciones impares.
fi=8;
for(i=0;i<h;i++)
{
textcolor(3);
gotoxy(15,7);cprintf("POSICIONES");
textcolor(i+1);
gotoxy(20,fi);cprintf("%c",vecimpar[i]);
fi=fi+1;
}
}
Inicio del programa
void main()
Sentencia do while
{
do
Borrar pantalla
{
Funcin borde
clrscr();
borde();
textcolor(2);
gotoxy(15,3);cprintf("VECTORES");
nomb();
Funciones
impar();
gotoxy(5,22);cprintf("Desea repetir 1 Salir 0: ");scanf("%d",&op);
}while(op==1);
Pausa
getch();
Fin del programa
}
pantalla
Programa 52.Disee un programa utilizando funciones y vectores que me permita leer una
cadena de caracteres y recorrer dicha cadena y encontrar solo aquellas que sean
consonantes, agruparlas y colocarlas en un nuevo vector.

ANLISIS
Empezamos abriendo las libreras para activar funciones, utilizamos variables de
tipo enteras y alfabticas tres funciones con sentencia for, una para el borde y
las dos restantes para realizar los procesos y al impresin de las
consonantes, un do-while para repetir los procesos cuantas veces se desee,
empezamos el programa con viod main, llamamos a las funciones, e imprimimos
resultados.
#include<stdio.h>
#include<string.h>
#include<ctype.h>
#include<conio.h>
char tex[20],tex1[20];
int i,n,fi,h,op;
void borde()
{
for(i=1;i<=79;i++)
{
textcolor(6);
}
for(i=2;i<=23;i++)
{
textcolor(6);
}
}
void conso()
{
flushall();
fi=9;
textcolor(5);
gotoxy(5,5);cprintf("TEXTO: ");
gets(tex);
gotoxy(5,8);cprintf("VECTOR");
n=strlen(tex);
Libreras.- coleccin de clases y funciones,

escritas en el ncleo del lenguaje.
Variables.- son un tipo de
datos, Alfabticas y
for(i=0;i<n;i++)
{
textcolor(5);
gotoxy(20,8);cprintf("CONSONANTES");
textcolor(i+1);
gotoxy(8,fi);cprintf("%c",tex[i]);

realizar el borde
Funciones.- Las funciones son bloques de cdigo

utilizados para dividir un programa en partes ms
pequeas
Color para el texto
Lectura de variables
Un vector, tambin llamado array(arreglo)

unidimensional, es una estructura de datos que
permite agrupar elementos del mismo tipo y
almacenarlos en un solo bloque de memoria
juntos, uno despus de otro.

fi=fi+1;
}
fi=9;
for(i=0;i<n;i++)
{
if(tex[i]!='a' && tex[i]!='e' && tex[i]!='i'
&& tex[i]!='o' && tex[i]!='u' )
S

impresin de las
{
letras en posiciones impares.
tex1[h]=tex[i];
textcolor(i+1);
gotoxy(25,fi);cprintf("%c",tex1[h]);
h=h+1;
fi=fi+1;
}
}
}
void main()
Inicio del programa
{
do
Sentencia do while
{
clrscr();
Borrar pantalla
borde();
Funcin borde
textcolor(5);
gotoxy(25,3);cprintf("VECTORES");
Funciones
conso();
gotoxy(5,22);printf("Repetir el proceso 1 salir 0: ");scanf("%d",&op);
}while(op==1);
Pausa
getch();
Fin del programa
}
pantalla
Programa 53
Enunciado:
Disee un programa utilizando vectores y funciones que me permita leer una cadena de caracteres y
presentarla de forma invertida
Codificacin:

#include<stdio.h>
Libreras
#include<string.h>
#include<conio.h>
int i,op,fila,a;
char nom[40];
void borde()
{
for(i=1;i<=80;i++)
{
Funcin global para el borde, e

inicio del ciclo, da color
textcolor(i+1);
gotoxy(i,1);printf("!");
gotoxy(i,24);printf("!");
Impresin del borde, cierre del

ciclo
}
for(i=2;i<=24;i++)
{
Funcin global para el borde, e
textcolor(i+1);
inicio del ciclo, da color
gotoxy(1,i);printf("!");
Impresin del borde
gotoxy(80,i);printf("!");
}
Cierre del ciclo y de la
funcin
void inver()
{
Funcin global e inicio
flushall();
gotoxy(20,6);printf("Ingrese la palabra: ");gets(nom);
Ingreso de datos con caracteres
a=strlen(nom);
y almacenaran en auxiliar
fila=9;
for(i=0;i<a;i++)
{
FOR

textcolor(i+1);
gotoxy(30,fila);cprintf("%c",nom[i]);
fila=fila+1;
Impresin del vector en forma
vertical
fila=8;
for(i=a;i>=0;i--)
{
Proceso de la forma
textcolor(i+1);
gotoxy(45,fila);cprintf("%c",nom[i]);
fila=fila+1;
}
Impresin del nuevo vector

invertido y con color
Cierre del ciclo y de la
funcin
void main()
{
Funcin principal e inicio
do
{
clrscr();
borde();
Limpiado de pantalla y
llamado de la funcin
gotoxy(32,2);printf("**Cadena de Caracteres Invertida**");

gotoxy(27,8);printf("Vector");
Impresin de mensajes
gotoxy(43,8);printf("Inversion");
inver();
Llamado de la funcin
gotoxy(12,22);printf("Digite 1 para continuar o 0 para salir : ");scanf("%d",&op);

}while(op==1);
getch();
}
Corrido:
Cierre del ciclo

Pausa y cierre del
programa
Anlisis:
En este programa hemos utilizado la variable char para declaracin con caracteres la
palabra, un g

e imprimir el en un nuevo vector todo esto se hace en una funcin global y al ltimo se llama
en una funcin principal void main
PROGRAMA 54
ENUNCIADO
Disee un programa utilizando vectores y funciones que me permita leer una

cadena de caracteres y recorrer dicha cadena y encontrar solo aquellas que sean
consonantes, agruparlas y colocarlas en un nuevo vector.
ANALISIS

Utilizo 4 libreras declaro dos variables tipo carcter y 7 variables de tipo entero utilizo 3
funciones la primera para el diseo del borde en pantalla la segunda funcin para sacar el
proceso de encontrar las consonantes y la tercera funcin es la principal utilizo un do while
para repetir el proceso
CODIFICACION
#include<conio.h>
#include<stdio.h>
#include<math.h>
#include<string.h>
char cad[25],c2[25];
//DECLARACION DE VARIABLES GLOBALES ENTERAS Y DE CARACTER//
int x,li,lim,i,p,l2;
int op=1;
void borde()
{
textcolor(YELLOW);
FUNCIN BORDE
for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)
{
//IMPRECION DE *\\
} //FIN DEL CICLO FOR \\
} // FIN DEL CICLO DE LA FUNCION DEL BORDE //
void caracter()
{
FUNCION
CONSONANTES
PARA
SACAR
gotoxy(5,5);printf("Cadena:");gets(cad); //IMPRIMO UN MENSAJE CON LA PALABRA CADENA\\
lim=strlen(cad);
li=7;// ACUMULADOR \\
p=0;//CONTADOR\\

for(i=0;i<lim;i++) // CICLO FOR PARA SACAR EL LIMITE DE LETRAS QUE QUIERO ENCONTRAR\\
{ // ABRO EL CICLO FOR\\

gotoxy(25,li);printf("%c\n",cad[i]); //IMPRIMO LA CANTIDAD DE LETRAS\\
li=li+1; //CONTADOR DEL CICLO FOR QUE SE BA IR SUMANDO DE UNO EN UNO\\
x=i; // AUXILIAR\\
(cad[i]);
if (x != 0)
{
if((cad[i] == 'a')||(cad[i] == 'e')||(cad[i] == 'i')||(cad[i] == 'o')||(cad[i] == 'u')) // CONDICIONES PARA ENCONTRAR LAS
C ONSONANTES\\
{
}
Else
// CASO CONTRARIO\\
{
c2[p]=cad[i];
p=p+1; // SIRVE PARA I R DE UNO EN UNO SUMANDO \\
}
}
}
li=7; // CONTADOR \\
lim=lim-1; //LIMITE MENOS1 \\
for(i=0;i<p;i++) //
{
gotoxy(45,li);printf("%c",c2[i]);//IMPRIMO CARACTER\\
li=li+1;//LIMITE MAS UNO\\
}
}
void main() // FUNCION PRINCIPAL\\
{ // INICIO DE LA FUNCION PRINCIPAL\\
Do //INICIO DE CICLO REPETITIVO CON UN DO PARA MAS ABAJO CERRAR CON WHILE \\
{
clrscr(); //LIMPIADO DE PANTALLA\\

borde(); // FUNCION BORDE\\
caracter(); // FUNCION CARCTER\\
gotoxy(30,2);cprintf("======================");
gotoxy(30,3);printf("POSICIONES CONSONANTES"); //IMPRIMO LAS POSICIONES DE LAS CONSONANTES\\
gotoxy(30,4);cprintf("======================");
gotoxy(22,6);printf("PALABRA"); //IMPRIMO LA PALABRA\\
gotoxy(40,6);printf("CONSONANTE");// IMPRIMO CONSONANTES\\
gotoxy(3,23);printf("DESEA REPETIR EL PROCESO 1 O 0 PARA SALIR: ");scanf("%d",&op);
}
while(op==1); // CICLO REPETITIVO \\
getch(); // PAUSA EN EL PROGRAMA\\
} //FIN DE LA FUNCION PRINCIPAL\\
CORRIDO
Programa 55
Disee un programa utilizando funciones que me permita automatizar el sistema de
recaudacin por concepto de matrculas a los estudiantes de la UNIANDES,
tomando en cuenta los siguientes parmetros.
Los aranceles universitarios por concepto de matrcula, estn estipulados de

acuerdo a los tipos de colegios.
Si es particular paga 250,00
o Servicio mdico que representa el 9% del valor de la matrcula
o Servicio de internet que el 10% del valor de la matrcula

o Servicio de canchas deportivas y servicios adicionales 12% del valor de la
matrcula
o Visualice los valores parciales y totales del costo de la matrcula.
Si es fiscomisional paga 180,00
matrcula
Si es fiscal paga 120,00
matrcula
o Visualice los valores parciales y totales del costo de la matrcula.
Todos pagan por derecho de carnet usd. 5,00

Visualice el nmero de estudiantes matriculados y el valor total recaudado por
concepto de matriculas
El proceso se repite tantas veces como el usuario lo decida
Se presenta el diseo del borde.
Programa 56
Enunciado
Disee un programa utilizando vectores y funciones que me permita Ingresar n
elementos entre 3 y 23 en las posiciones impares del vector y las posiciones pares
se generan con cualquier factor ingresado desde teclado, recorra el vector y
encuentre todos aquellos valores que sean nmeros primos y asignarlos a un nuevo
vector, presente el vector resultante ordenado en forma ascendente y descendente.
Anlisis
1.
2.
3.
4.
5.
Codificamos el borde dentro de una funciones

Dentro de otra funciones ingresamos un lmite y un factor
Si la posiciones es par debemos condicionar el valor ingresado entre 3 y 23
Si la posiciones es impar realizamos el proceso para que se genere el factor
Realizamos otra funcin para imprimir los nmeros que sean nicamente
primos
6. Utilizamos un for para verificar si los datos son primos, de ser as se asignara
dicho valor a un vector
7. Utilizamos otra funcin para ordenar de forma ascendente los valores
asignados al vector de nmeros primos

8. De igual manera utilizamos una funcin para ordenar de forma descendente
los valores asignados al vector de los nmeros primos.
9. Abrimos la funcin del programa principal
10. Llamamos las funciones previamente codificadas
Documentacin
Libreras
Declaracin de Variables int
Inicio de funcin borde
Lazo For
Fin de funcin
Funcin de ingreso
Ingresos e impresiones
Inicializaciones
Lazo For
#include<stdio.h>
#include<conio.h>
int i,lim,fac,op,vect1[15],f,fila,d,aux,c,a,vec[15],j,lim2;
void borde()
{
for(i=1;i<=80;i++)
{
textcolor(i);
}
for(i=1;i<=24;i++)
{
textcolor(i);
}
}
void ingreso()
{
gotoxy(31,5);printf("PROCESO DE VECTORES");
gotoxy(15,7);printf("Limite>> ");scanf("%d",&lim);
gotoxy(45,7);printf("Factor>> ");scanf("%d",&fac);
gotoxy(13,10);printf("Entrada");
f=0;
fila=11;
for(i=1;i<=lim;i++)
{
if(i%2==0)
{
do
{
gotoxy(15,fila);scanf("%d",&vect1[i]);
}while(vect1[i]<3 || vect1[i]>23);
}
if(i%2==1)
{
f=f+fac;
vect1[i]=f;
gotoxy(15,fila);printf("%d",vect1[i]);
}
fila=fila+1;
Fin de funcin
Funciones primos
Inicializacin variables
Lazo For
Condicin If
Fin funcin
Funcin Ascendente
Lazo For
Fin de funcin
}
}
void primos()
{
lim2=1;
fila=11;
gotoxy(25,10);printf("#s Primos");
for(i=1;i<=lim;i++)
{
a=0;
for(j=1;j<=vect1[i];j++)
{
if(vect1[i]%j==0)
{
a=a+1;
}
}
if(a==2)
{
vec[lim2]=vect1[i];
gotoxy(26,fila);printf("%d",vec[lim2]);
fila=fila+1;
lim2=lim2+1;
}}}
void ascendente()
{
for(i=1;i<lim2;i++)
{
for(j=1;j<lim2;j++)
{
if(vec[i]<vec[j])
{
aux=vec[i];
vec[i]=vec[j];
vec[j]=aux;
}
}
}
fila=11;
for(i=1;i<lim2;i++)
{
gotoxy(38,10);printf("Ascendente");
fila=fila+1;
}
}//cierre
Funcin descendente
Lazo for
Fin de funcin
Funcin principal
Llamado de funciones
Lazo Do While
Fin de funcin
Corrido
void descendente()
{
for(i=1;i<lim2;i++)
{
for(j=1;j<lim2;j++)
{
if(vec[i]>vec[j])
{
aux=vec[i];
vec[i]=vec[j];
vec[j]=aux;
}
}
}
fila=11;
for(i=1;i<lim2;i++)
{
gotoxy(58,10);printf("Descendente");
fila=fila+1;
}
}//cierre
void main()
{
do
{
clrscr();
borde();
ingreso();
primos();
ascendente();
descendente();
getch();
gotoxy(10,22);printf("Presione 1/0>> ");scanf("%d",&op);
}while(op==1);
}
Programa 57
1. ENUNCIADO:
Disee un programa utilizando funciones y matrices que me permita visualizar los
datos en una matriz y otra matriz resultante con los datos ingresados.
2. ANLISIS:
En este programa utilizaremos funciones tanto para el borde como para ingresar y
presentar los datos de nuestra matriz, esencialmente la utilizacin de ciclos FOR
para que permita ingresar los datos de nuestra matriz, imprimimos resultados y
utilizamos un DO-WHILE para que el programa se repita n veces quiera el usuario.
3. DOCUMENTACION:
#include<stdio.h>
Libreras

#include<conio.h>
int j,i,k,op,matriz1[10][10],col=10,fila=8,limite,datos,sali,f;
void borde()
{
for(k=2;k<=80;k++)
{
gotoxy(k,2);printf("-");
gotoxy(k,24);printf("-");
}
Funcin para el diseo del
for(k=2;k<=24;k++)
borde
{
gotoxy(2,k);printf("-");
gotoxy(80,k);printf("-");
}
}
void ing(int datos)
{
col=10;
fila=8;
{
Funcin para el ingreso de los
{
datos de la matriz utilizando
gotoxy(col,fila); scanf("%d",&matriz1[i][j]);
ciclos FOR
col=col+5;
}
col=10;
fila=fila+1;
}
}
void sal(int sali)

{
fila=8;
col=40;
for(i=1;i<=limite; i++)
Funcin para la impresin de
{
nuestra matriz utilizando ciclos
{
FOR
gotoxy(col,fila); printf("%d",matriz1[i][j]);
col=col+5;
}
col=40;
fila=fila+1;
}
}
Cuerpo
principal
del
void main()
programa
{
do
Ciclo DO-while para repetir n veces
{

clrscr();
borde();
Blanqueo
de
Llamado de la funcin del
gotoxy(3,3); printf("Ingrese un lmite: "); scanf("%d",&limite);

ing(datos);
Llamado de las funciones de la matriz
sal(sali);
gotoxy(4,22); printf("NUEVO 1 SALIR 0: "); scanf("%d",&op);
}
while(op==1);
getch();
}
Pausar
Ingreso del lmite de
Ciclo DO-while para repetir n

veces
4. CORRIDO DEL PROGRAMA:
Programa 58
Disee un programa utilizando funciones y matrices que me permita generar una matriz con
cualquier factor ingresado desde teclado.
ANALISIS
Este programa me permite ingresar una matriz de cualquier orden y se imprime los factores
ingresados en toda la matriz.
Ingresamos la libreras y las variables globales abrimos una funcin para el borde e
ingresamos textcolor(YELLOW); para escoger el color mediente lazos for hacemos el
proceso del borde y cerramos el mismo, abrimos la funcin del programa ingresamos en una
variable para que se almacene el factor, tambin se ingresa las filas y columnas de la matriz,
sumamos el factor para la variable ingresada ubicamos las posiciones de la matriz y
cerramos el programa. Abrimos la funcin para llamar al proceso ingreso un lazo repetitivo,

un limpiador de pantalla,llamo a la funcin del borde y del programa cierro el lazo repetitivo
ingreso un getch para que no haiga un eco y por ultimo cierro todo el programa
#include<stdio.h>
#include<conio.h>
LIBRERIAS
#include<ctype.h>
int i,j,m,matriz[5][5],columna,fila,limite,datos,factor,a,op; VARIABLES GLOBALES
void borde(int datos)
SE ABRE LA FUNCION DEL BORDE
{
textcolor(YELLOW);
ESCOGER EL COLOR
for(i=1;i<=80;i++)
{
}
PROCESO DEL BORDE
for(i=1;i<=24;i++)
{
}
}
SE CIERRA LA FUNCION
void programa(int datos)
FUNCION DEL PROGRAMA
{
SE ABRE LA FUNCION
a=0;
gotoxy(33,3);cprintf("MATRIZ FACTOR");
gotoxy(8,5);cprintf("Limite: ");scanf("%d",&datos);
gotoxy(8,6);cprintf("Factor: ");scanf("%d",&factor);
ENUNCIADOS
columna=10;
fila=10;
for(i=1;i<=datos; i++)
PROCESO DE LA MATRIZ
{
for(j=1;j<=datos; j++)
{
gotoxy(8,8);cprintf("Matriz ingreso");
a=a+factor;
matriz[i][j]=a;
gotoxy(columna,fila);printf("%d",matriz[i][j]);
columna=columna+4;
PROCESO DEL FACTOR
}
columna=10;
fila=fila+2;

}
a=0;
columna=50;
fila=10;
for(i=1;i<=datos; i++)
{
for(j=1;j<=datos; j++)
{
gotoxy(45,8);cprintf("Matriz resultante");
a=a+factor;
matriz[i][j]=a;
PROCESO PARA COPIAR ALADO
EL FACTOR
columna=columna+4;
}
columna=50;
fila=fila+2;
}
}
void main ()
SE ABRE LA FUNCION PARA LLAMAR AL PROGRAMA
{
do
{
SE ABRE EL LAZO REPETITIVO
clrscr ();
LIMPIADOR DE PANTALLA
borde(datos);
programa(datos);
LLAMA A LAS FUNCIONES
gotoxy(3,23);cprintf("DESEA REPETIR PRESIONE 1 O 0 PARA SALIR: ");scanf("%d",&op);
}
SE CIERRA EL LAZO REPETITIVO
while(op==1);
getch();
PARA QUE NO EXISTA ECO
}
SE CIERRA EL PROGRMA
Programa 59
Disee un programa utilizando funciones y matrices que me permita Imprimir una matriz
cuadrtica de ceros excepto la diagonal principal.
ANALISIS
Este programa me permite ingresar una matriz de cualquier orden y se imprime de ceros y
su diagonal principal de unos.
Ingresamos las libreras introducimos las variables globales abrimos la funcin del borde
ingresamos un textcolor(YELLOW); para darle color al diseo mediante lazos for asemos el
margen de la pantalla y cerramos la funcin abrimos la funcin del programa para la matriz
visualizamos el lmite que se desea ingresar ingresamos dos lazos for con (i,j) para formar a
la matriz, ingresamos una condicin si el nmero de la fila es igual al de la columna se
imprima con unos caso contrario de ceros cerramos la funcin. Por ultimo abrimos void
main() para llamar al programa abrimos un lazo repetitivo escribimos un clrscr para limpiar
la pantalla llamamos al borde y al programa y cerramos el programa
#include<conio.h>
#include<stdio.h>
LIBRERIAS
#include<ctype.h>
int op=1,limite,fila=7,columna=13,i,j;
INGRESAMOS VARIABLES GLOBALES
int matriz[10][10],datos;
void borde()
FUNCION DEL BORDE
{
textcolor(YELLOW);
INGRESAR COLOR
for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)
PROCESO DEL BORDE
{
}
}
CIERRO LA FUNCION
void programa(int datos)
FUNCION DEL PROGRAMA
{
ABRIR LA FUNCION
gotoxy(3,5);cprintf("Limite: ");cscanf("%d",&limite);
INGRESAR UN LIMITE
{
ORDENAR LA MATRIZ

{
if(i==j)
{
matriz[i][j]=1;
gotoxy(columna,fila);cprintf("%d",matriz[i][j]);
REALIZA UNA CONDICION
columna=columna+5;
}
else
{
matriz[i][j]=0;
columna=columna+5;
CASO CONTRARIO
}
}
fila=fila+1;
columna=13;
}
}
void main()
FUNCION PARA LLAMAR AL PROGRAMA
{
ABRIR LA FUNCION
do
{
ABRIR UN LAZO REPETITIVO
clrscr();
LIMPIADOR DE PANTALLA
borde();
SE LLAMA A LA FUNCION BORDE
gotoxy(36,2);cprintf("========");
gotoxy(37,3);cprintf("MATRIZ");
ENUNCIADO
gotoxy(36,4);cprintf("========");
programa (datos);
gotoxy(3,23);cprintf("DESEA REPETIR 1 O 0 PARA SALIR: ");cscanf("%d",&op);
}
while(op==1);
CIERRO LA FUNCION
getch();
PARA QUE NO EXISTA ECO
}
Programa 60
Disee un programa utilizando matrices y funciones que me permita llenar una
matriz con valores ceros, a excepcin de sus diagonales, en donde la diagonal
principal se llena con un factor cualquiera ingresado desde teclado y la diagonal
secundaria con el factorial, visualice la diagonales principal y secundaria.
Anlisis
Necesitamos funciones para realizar el ejercicio tambin necesitamos matrices
necesitamos variables globales para generar un factor cualquiera y otra variable
para generar el factorial.
Documentacin
#include<conio.h>
#include<stdio.h>
librerias
int op,i,j,fi,c,n,ma[50][50],f,cf,fac;
void borde()
{
for(i=1;i<=79;i++)
{
}
Funcin borde
for(i=2;i<=23;i++)
{
}
}
void presen(int m)
{
c=15;
fi=5;
cf=0;
gotoxy(15,4);printf("Ingrese factor: ");scanf("%d",&f);
for(i=1;i<=m;i++)
{
for(j=1;j<=m;j++)
{
if(i==j)
{
cf=cf+f;
ma[i][j]=cf;
gotoxy(c,fi);printf("%d",ma[i][j]);
Ingreso de la matriz

c=c+3;
}
Contador
else
{
ma[i][j]=0;
c=c+3;
}
}
c=15;
fi=fi+1;
}
}
void diago(int m)
{
c=45;
fi=5;
cf=0;
Ciclo
for(i=1;i<=m;i++)
fortador
{
for(j=1;j<=m;j++)
{
if(i==j)
{
Ciclo
cf=cf+f;
ma[i][j]=cf;
fortador
c=c+3;
}
}
fi=fi+1;
}
Ierre de los ciclofuncions for
}
void diagosec(int m)
Inicio de otra
{
c=45;
fi=5;
fac=1;
for(i=1;i<=n;i++)
{
for(j=m;j>=1;j--)
{
if(i==j)
{
fac=fac*j;
ma[i][j]=fac;
c=c+3;
}
c=c+3;

clrscr();
borde();
gotoxy(32,2);printf("INGRESO MATRICES");
gotoxy(15,3);printf("Ingrese el limite: ");scanf("%d",&n);
presen(n);
diago(n);
diagosec(n);
diagosecu(n);
}while(op==1);
getch();
}
Corrido
Imprecion
Programa 61
Disee un programa utilizando funciones y matrices que me permita Generar una
matriz con la serie del fibonasi, encontrar los datos de sus diagonales visualizarlos
en forma de equiz, asignar estos datos a un vector resultante ordenado en forma
ascendente y descendente.
Anlisis
Para este programa utilizamos funciones para llamar al procedimiento para realizar
el ejercicio tambin necesitamos matrices, variables globales para generar poder
realizar los respectivos procedimientos para generar la serie del fibonasi y asi
proseguir a llamar a las distintas funciones en donde se visualice la matriz las
diagonales otra para ordenar ascendentemente y otra para ordenar
descendentemente.
Documentacin
#include<conio.h>
Libreras
#include<stdio.h>
int fil, col, aux, i, j, mat[10][10], vect[10], lim, op, a, b, c, h;
void bdob()
{
int i;
clrscr();
for(i=2;i<=79;i++)
{
}
for(i=2;i<=23;i++)
{
Funcin global para el

borde

}
}
void diag()
{
col=5;
Inicio de la funcin para

determinar las
fil=8;
a=1;
b=0;
c=0;
for(i=1;i<=lim;i++)
{
Condicin para calcular las

diagonales
for(j=1;j<=lim;j++)
{
c=a+b;
a=b;
b=c;
mat[i][j]=c;
Proceso para calcular la

serie del fibonasi
gotoxy(col,fil);printf("%d",mat[i][j]);
col=col+4;
}
col=5;
fil=fil+3;
}
}
void dprinc()
{
col=21;
fil=8;
Inicio de la funcin
calcular la diagonal
principal

h=1;
for(i=1;i<=lim;i++)
{
for(j=1;j<=lim;j++)
{
Condicin para calcular la

diagonal
if(i==j)
{
vect[h]=mat[i][j];
h=h+1;
col=col+4;
}
}
fil=fil+3;
}
}
void dsec()
{
col=28;
Funcin para calcular la

diagonal secundaria
fil=8;
j=lim;
for(i=1;i<=lim;i++)
{
vect[h]=mat[i][j];
h=h+1;
j=j-1;
col=col-4;
fil=fil+3;
}
Imprimimos la matriz

}
void diag_vect()
{
fil=8;
for(i=1;i<h;i++)
{
gotoxy(41,fil);printf("%d",vect[i]);
fil=fil+2;
}
}
void orden()
{
fil=8;
Funcin para ordenar las

diagonales.
for(i=1;i<h;i++)
{
for(j=1;j<h;j++)
{
if(vect[i]<vect[j])
{
aux=vect[i];
vect[i]=vect[j];
vect[j]=aux;
}
}
}
fil=8;
for(i=1;i<h;i++)
{
fil=fil+2;
Calculamos el vector
descendente

}
for(i=1;i<h;i++)
{
for(j=1;j<h;j++)
{
Proceso para ordenar
if(vect[i]>vect[j])
{
aux=vect[i];
vect[i]=vect[j];
vect[j]=aux;
}
}
}
fil=8;
for(i=1;i<h;i++)
{
fil=fil+2;
}
}
void main()
{
do
{
clrscr();
bdob();
gotoxy(34,2);printf("<<MATRICES>>");
gotoxy(5,4);printf("Ingrese el limite>> ");scanf("%d",&lim);
gotoxy(4,6);printf("<<MATRIZ>>");
gotoxy(18,6);printf("<<Diagonales>>");
Funcin donde a
proseguimos a imprimir
los datos

gotoxy(34,6);printf("<<Vector_Diag>>");
gotoxy(50,6);printf("<<Ascendente>>");
gotoxy(65,6);printf("<<Descendente>>");
Pedimos los respectivos

datos.
diag();
dprinc();
dsec();
diag_vect();
orden();
gotoxy(3,22);printf("Presione 1 para volver a repetir el proceso o 0 para finalizar>>
");scanf("%d",&op);
}
while(op==1);
getch();
}
Corrido.
Programa 62
Disee un programa utilizando matrices y funciones que me permita generar una
matriz con nmeros pares, a excepcin de sus diagonales, las mismas que se llenan
con nmeros impares, recorra la matriz y encuentre los dtos de sus diagonales y
guarderlas en vector.
Anlisis
Primero ingresamos las libreras que vamos a utilizar en este programa en este caso
son las dos principales la STDIO.H Y LA CONIO.H, despus como es un programa
con funciones declaramos las variables que vamos a utilizar globalmente
proseguimos a nombrar una funcin llamada borde para que nuestro programa se
visualice con un borde y otra funcin en donde realicemos los clculos de la matriz
para finalizar realizamos el programa principal con un VOID MAIN y proseguimos a
llamar cada funcin e imprimimos.
CODIGO
#include<stdio.h>
#include<conio.h>
int a,i,j,lim,imp,b,matriz[10][10],col,fil,op;
void borde()
{
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("+");
gotoxy(i,24);printf("+");
}
for(i=1;i<=24;i++)
{
}
}
void mat()
{
a=2;
b=1;
col=5;
fil=10;
for(i=0;i<lim;i++)
{
for(j=0;j<lim;j++)
{
if(i==j || j==(lim-1)-i)
{
matriz[i][j]=b;
b=b+2;
}
Libreras que vamos a utilizar en el

Declaramos
la
variable
global
Realizamos la funcin para que se

pueda realizar un borde en nuestro
Inicio de la funcin para realizar el calculo

de la matriz
Calculamos las diagonales de la

matriz
con
numeros
impares
rellenamos la matriz con numeros

pares

else{
matriz[i][j]=a;
a=a+2;
}
gotoxy(col,fil);printf("%d",matriz[i][j]);
col=col+4;
}
fil=fil+2;
col=5;
}
}
void main()
{
do
{
clrscr();
borde();
gotoxy(3,4);printf("Ingrese el limite > "); scanf("%d",&lim);
mat();
gotoxy(3,22); printf("1 continuar 0 salir > "); scanf("%d",&op);
}
while(op==1);
getch();
}
Corridor.
En esta funcin ya
proseguimos
llamar a las otras

funciones
BIBLIOGRAFIA:
http://ejercicioscpp.blogspot.com/2012
/09/tipos-de-datos-en-c.html
http://www.nachocabanes.com/tutors/teoc-lebron.pdf
http://utch2009.files.wordpress.com/2010/02/manual-de-turbo-c.pdf
http://www.taringa.net/posts/ebooks-tutoriales/14600832/Funciones-ysentencias-de-programacion-en-C.html
http://blog.espol.edu.ec/programando/sentencia-repetitiva-for-lenguaje-c/
http://logpracticas2013.blogspot.com/2013/04/c-introduccion-de-datoscontadores-y.html
http://www.programacionfacil.com/cpp/funciones.
http://books.google.es/books?hl=es&lr=&id=n9VEG2Gp5pkC&oi=fnd&pg=PR1
7&dq=C%2B%2B+TUTORIAL&ots=Rem4npbdOQ&sig=Tev8U08QBBkpEENd
sFAUs4L1aRs#v=onepage&q=C%2B%2B%20TUTORIAL&f=false
http://www.flipsnack.com/9A6E898F8D6/fdnfbfi9

C

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

C

Caricato da

Copyright:

Formati disponibili

UNIVERSIDAD TCNICA DE AMBATO

FACULTAD DE CIENCIA HUMANAS DE LA

C++ - Ashqui Israel 3

C++ - Ashqui Israel 4

C++ - Ashqui Israel 5

C++ - Ashqui Israel 6

C++ - Ashqui Israel 7

C++ - Ashqui Israel 8

C++ - Ashqui Israel 9

C++ - Ashqui Israel 10

El nombre C++ fue propuesto por Rick Mascitti en el ao 1983, cuando el

C++ - Ashqui Israel 11

Tiene un conjunto completo de instrucciones de control.

Permite la agrupacin de instrucciones.

Comandos breves (poco tecleo).

El generar programas eficientes.

Un punto en contra es que tiene una deteccin pobre de errores, lo cual en

La posibilidad de poder ser compilado en una variedad de computadoras, con

C++ - Ashqui Israel 12

Tipos de datos en C++

Entero sin signo

Carcter sin signo

C++ - Ashqui Israel 13

Tipos de datos numricos reales.

Dato de tipo lgico

Tipo carcter extendido

C++ - Ashqui Israel 14

Tipos de datos simples

void: Tipo de dato que no tiene valor.

C++ - Ashqui Israel 15

Funciones de E/S bsicas

Entero decimal con

scanf(%d,&x); /* Se lee la variable como entera */

C++ - Ashqui Israel 16

C++ - Ashqui Israel 17

De las cuales las mas utilizadas son:

C++ - Ashqui Israel 18

C++ - Ashqui Israel 19

SINTAXIS DE LAS SENTENCIAS Y FUNCIONES DE C

1. Fichero de cabecera que contiene las declaraciones y definiciones relativas a

Segn lo expuesto, la siguiente sentencia no sera vlida:

C++ - Ashqui Israel 20

ENTRADA Y SALIDA ESTANDAR

C++ - Ashqui Israel 21

C++ - Ashqui Israel 22

Ej: Pide al usuaro qu quiere hacer con dos nmeros.

C++ - Ashqui Israel 23

CREACIN DE BUCLES ANIDADOS

C++ - Ashqui Israel 24

C++ - Ashqui Israel 25

C++ - Ashqui Israel 26

C++ - Ashqui Israel 27

C++ - Ashqui Israel 28

La instruccin RETURN es quien regresa un y solo un dato a la parte del programa

C++ - Ashqui Israel 29

Vectores, Matrices y Punteros en c++

Crear un vector en C++ es sencillo, seguimos la siguiente sintaxix:

C++ - Ashqui Israel 30

C++ - Ashqui Israel 31

C++ - Ashqui Israel 32

C++ - Ashqui Israel 33

cout << "Variable a = " << a << endl;

C++ - Ashqui Israel 34