Las Generalidades de la
Programación
Estructurada
Turbo C++

07 de Enero de 2014
Universidad Técnica de Ambato
Estefanía Sánchez Núñez
INDICE

Tabla de contenido
¿Qué es el Turbo C++? .................................................................................................................4
CARACTERÍSTICAS ................................................................................................................1
ELEMENTOS BÁSICOS DEL LENGUAJE C ........................................................................2
ESTRUCTURA ..........................................................................................................................4
COMENTARIOS ........................................................................................................................5
IDENTIFICADORES .................................................................................................................6
TIPOS DE DATOS ....................................................................................................................6
SALIDA / ENTRADA ...............................................................................................................11
SENTENCIAS CONDICIONALES ........................................................................................14


Estructura IF...ELSE ..................................................................................................14



Estructura SWITCH ...................................................................................................15

BUCLES ...................................................................................................................................16


Sentencia WHILE .......................................................................................................16

Sentencia DO...WHILE .......................................................................................................17
Sentencia FOR ....................................................................................................................18
Sentencia BREAK ...............................................................................................................19
Sentencia CONTINUE ........................................................................................................19
FUNCIONES ............................................................................................................................20


Funciones ....................................................................................................................21

VECTORES..............................................................................................................................25
MATRICES ...............................................................................................................................28
LIBRERÍAS...............................................................................................................................33
Librería stdio.h .....................................................................................................................33
Librería stdlib.h ....................................................................................................................34
Librería conio.h ....................................................................................................................34
Librería string.h ....................................................................................................................35
BIBLIOGRAFIA ........................................................................................................................95

2
INTRODUCCIÓN
C es un lenguaje de programación de propósito general que ofrece economía
sintáctica, control de flujo y estructuras sencillas y un buen conjunto de
operadores. No es un lenguaje de muy alto nivel y más bien un lenguaje
pequeño, sencillo y no está especializado en ningún tipo de aplicación. Esto lo
hace un lenguaje potente, con un campo de aplicación ilimitado y sobre todo,
se aprende rápidamente. En poco tiempo, un programador puede utilizar la
totalidad del lenguaje.

3
¿Qué es el Turbo C++?
Turbo C es un Entorno de desarrollo integrado y compilador para programar en
lenguaje C, desarrollado por Borland.

El Turbo C++ es un lenguaje de programación que nos ayuda a desarrollar
aplicaciones de distintos tipos, como por ejemplo: juegos programas
educativos, científicos y hasta de administración de bases de dato.

El Turbo C++ se utiliza bajo el sistema operativo DOS, pero se puede acceder
a él desde windows. Normalmente cuando se instala el Turbo C++ sus archivos
se almacenan dentro de una carpeta llamada TC.

4
CARACTERÍSTICAS


El lenguaje C se conoce como un lenguaje compilado. Existen dos tipos
de lenguaje: interpretados y compilados. Los interpretados son aquellos
que necesitan del código fuente para funcionar.
Ejemplo: Basic. Los compilados convierten el código fuente en un
fichero objeto y éste en un fichero ejecutable.



Podemos decir que el lenguaje C es un lenguaje de nivel medio, ya que
combina elementos de lenguaje de alto nivel con la funcionalidad del
lenguaje ensamblador. Es un lenguaje estructurado, ya que permite
crear procedimientos en bloques dentro de otros procedimientos. Hay
que destacar que el C es un lenguaje portable, ya que permite utilizar el
mismo código en diferentes equipos y sistemas informáticos: el lenguaje
es independiente de la arquitectura de cualquier máquina en particular.



Por último solo queda decir que el C es un lenguaje relativamente
pequeño; se puede describir en poco espacio y aprender rápidamente.

1
ELEMENTOS BÁSICOS DEL LENGUAJE C
Un programa en C++ está definido por funciones, grupo de instrucciones que
pueden o no hacer algún cálculo, donde la función principal debe ser llamada
main. La composición general de un programa en C++ es:

Directivas de pre
procesamiento

Declaración
global

Función main

Funciones
definidas po

Comentarios
para entender el
funcionamiento
del programar el
usuario

2
 Directivas
Las directivas de pre procesamiento son definidas para que el compilador
realice algo antes de compilar el programa, revisar si la sintaxis es correcta y
generar un código ejecutable por la computadora, como el incluir funciones de
alguna biblioteca conocida.
La directiva para incluir bibliotecas es como las siguientes:
Ejemplo:
#include <iostream.h>
Esta directiva permitirá utilizar la función de lectura cin y la función de
escritura cout propias de C++.
#include <stdio.h>
Esta directiva permitirá utilizar las funciones de lectura y escritura propias de C.
 Declaraciones Globales
Las declaraciones globales son definiciones de variables o constantes que
serán utilizadas por cualquiera de todas las funciones definidas en el programa.
La sintaxis para la declaración de una variable es:
Tipo var1, var2,..., var3; o bien
Tipo var1= valor, var2,..., var3;
 Función main
La función main( ), es obligatoria en cada programa C, C++. Indica el comienzo
del programa y requiere los paréntesis ( ) a continuación de main( ).

 Funciones definidas por el usuario
La definición de una función se realiza escribiendo primero el tipo del valor de
retorno de la función, después el nombre de la función, posteriormente entre
paréntesis las variables que utilizará dicha función, parámetros, y finalmente las
instrucciones de la función.

3
Ejemplo:
double promedio ( int a, int b, int c)
{

return (a + b + c ) / 3.0; }

Declara a la función promedio, la cual recibe tres valores enteros y calcula y
regresa el promedio de ellos.

 Comentarios
Los comentarios pueden escribirse utilizando alguna de las siguientes formas:
comentando en la misma línea, utiliza //,
Ejemplo:
int edad; // la edad se utilizará como un valor entero.
Comentando entre varias líneas, utiliza /*
*/,

ESTRUCTURA
Todo programa en C consta de una o más funciones, una de las cuales se
llama main. El programa comienza en la función main, desde la cual es posible
llamar a otras funciones.
Cada función estará formada por la cabecera de la función, compuesta por el
nombre de la misma y la lista de argumentos, la declaración de las variables a
utilizar y la secuencia de sentencias a ejecutar.
Ejemplo:
declaraciones globales
main( )
{
variables locales
bloque
}
funcion1( )
{
variables locales
bloque
}
4
COMENTARIOS
A la hora de programar es conveniente añadir comentarios para poder saber
que función tiene cada parte del código, en caso de que no lo utilicemos
durante algún tiempo. Además facilitaremos el trabajo a otros programadores
que puedan utilizar nuestro archivo fuente.
Para poner comentarios en un programa escrito en C usamos los símbolos /*y
*/:
/* Este es un ejemplo de comentario */
/* Un comentario también puede
Estar escrito en varias líneas */
El símbolo /* se coloca al principio del comentario y el símbolo */ al final.
El comentario, contenido entre estos dos símbolos, no será tenido en cuenta
por el compilador.

Palabras clave
Existen una serie de indicadores reservados, con una finalidad determinada,
que no podemos utilizar como identificadores.
A continuación vemos algunas de estas palabras clave:

char

int

float

double if

else

do

while

short

long

extern static

default

break

sizeof

continue

for

register

typedef

5

switch
IDENTIFICADORES
Un identificador es el nombre que damos a las variables y funciones. Está
formado por una secuencia de letras y dígitos, aunque también acepta el
carácter de subrayado. Por contra no acepta los acentos ni la ñ/Ñ.
El primer carácter de un identificador no puede ser un número, es decir que
debe ser una letra o el símbolo.
Se diferencian las mayúsculas de las minúsculas, así num, Num y nuM son
distintos identificadores.

TIPOS DE DATOS


Enteros

Dentro de los enteros están los tipos: short, int, long, los cuales varían en
rango de acuerdo al compilador que se utilice, siendo long rango mayor y
short el de menor.


Flotantes

Dentro de los flotantes C++ tiene los tipos: float, double y long double donde
al igual que los enteros varía el rango de cada uno de acuerdo al
compilador que se utilice. De igual forma el float es el de menor rango
siendo long double el de rango mayor.


Caracteres

Se utiliza el tipo char. Para representar un carácter en C++ se utilizan
apóstrofes.
Ejemplos: „a‟, „b‟ , „5‟
Para representar una cadena de caracteres se utilizan las comillas.
Ejemplo: “soy una cadena”

6
TIPO
char
int
float
double

Tamaño
1 byte
2 bytes
4 bytes
8 bytes

Rango de valores
-128 a 127
-32768 a 32767
3'4 E-38 a 3'4 E+38
1'7 E-308 a 1'7 E+308

Calificadores de tipo
Los calificadores de tipo tienen la misión de modificar el rango de valores de un
determinado tipo de variable. Estos calificadores son cuatro:
 signed
Le indica a la variable que va a llevar signo. Es el utilizado por defecto.
Tamaño
signed char 1 byte
signed int
2 bytes

Rango de valores
-128 a 127
-32768 a 32767

 unsigned
Le indica a la variable que no va a llevar signo (valor absoluto).
Tamaño
unsigned char 1 byte
unsigned int
2 bytes

rango de valores
0 a 255
0 a 65535

 short
Rango de valores en formato corto (limitado). Es el utilizado por defecto.
Tamaño
short char
short int

1 byte
2 bytes

rango de valores
-128 a 127
-32768 a 32767

 long
Rango de valores en formato largo (ampliado).
Tamaño
long int
4 bytes
long double 10 bytes

rango de valores
-2.147.483.648 a 2.147.483.647
-3'36 E-4932 a 1'18 E+4932

También es posible combinar calificadores entre sí:
signed long int = long int = long
unsigned long int = unsigned long
4 bytes

0 a 4.294.967.295 El mayor entero permitido en 'C'
7
Las variables
Una variable es un tipo de dato, referenciado mediante un identificador llamado
de la variable. Su contenido podrá ser modificado a lo largo del programa.
Una variable sólo puede pertenecer a un tipo de dato. Para poder utilizar una
variable, primero tiene que ser declarada:
[calificador] <tipo> <nombre>
Es posible inicializar y declarar más de una variable del mismo tipo en la misma
sentencia:
[calificador]<tipo><nombre1>,<nombre2>=<valor>,<nombre3>=<valor>,<no
mbre4>
Ejemplo:
/* Uso de las variables */
#include <stdio.h>
main() /* Suma dos valores */
{
int num1=4,num2,num3=6;
printf("El valor de num1 es %d",num1);
printf("nEl valor de num3 es %d",num3);
num2=num1+num3;
printf("nnum1 + num3 = %d",num2);
}

¿Dónde se declaran?
Las variables pueden ser de dos tipos según el lugar en que las declaremos:
globales o locales.
La variable global se declara antes de la main( ). Puede ser utilizada en
cualquier parte del programa y se destruye al finalizar éste.

8
La variable local se declara después de la main( ), en la función en que vaya a
ser utilizada. Sólo existe dentro de la función en que se declara y se destruye al
finalizar dicha función.
El identificador, nombre de la variable, no puede ser una palabra clave y los
caracteres que podemos utilizar son las letras: a-z y A-Z, la ñ o Ñ no está
permitida, los números: 0-9 y el símbolo de subrayado. Además hay que tener
en cuenta que el primer carácter no puede ser un número.
Ejemplo:
/* Declaración de variables */
#include <stdio.h>
int a;
main() /* Muestra dos valores */
{
int b=4;
printf("b es local y vale %d",b);
a=5;
printf("na es global y vale %d",a);
}

Constantes
Al contrario que las variables, las constantes mantienen su valor a lo largo de
todo el programa.
Para indicar al compilador que se trata de una constante, usaremos la directiva
#define:
#define <identificador> <valor>
Observa que no se indica el punto y coma de final de sentencia ni tampoco el
tipo de dato.
La directiva #define no sólo nos permite sustituir un nombre por un valor
numérico, sino también por una cadena de caracteres.
El valor de una constante no puede ser modificado de ninguna manera.
Ejemplo:
/* Uso de las constantes */
#include <stdio.h>
#define pi 3.1416
9
#define escribe printf
main() /* Calcula el perímetro */
{
int r;
escribe("Introduce el radio: ");
scanf("%d",&r);
escribe("El perímetro es: %f",2*pi*r);
}

Secuencias de escape
Ciertos caracteres no representados gráficamente se pueden representar
mediante lo que se conoce como secuencia de escape.
A continuación vemos una tabla de las más significativas:

n

salto de línea

b

retroceso

t

tabulación horizontal

v

tabulación vertical



contrabarra

f

salto de página

'

apóstrofe

"

comillas dobles

0

fin de una cadena de caracteres

Ejemplo:
/* Uso de las secuencias de escape */
#include <stdio.h>
main() /* Escribe diversas sec. de escape */
{
printf("Me llamo "Nemo" el grande");

10
printf("nDirección: C Mayor 25");
printf("nHa salido la letra 'L'");
printf("nRetrocesob");
printf("ntEsto ha sido todo");
}

Inclusión de ficheros
En la programación en C es posible utilizar funciones que no estén incluidas en
el propio programa. Para ello utilizamos la directiva #include, que nos permite
añadir librerías o funciones que se encuentran en otros ficheros a nuestro
programa.
Para indicar al compilador que vamos a incluir ficheros externos podemos
hacerlo de dos maneras, siempre antes de las declaraciones.
1. Indicándole al compilador la ruta donde se encuentra el fichero.
#include "misfunc.h"
#include "c:includesmisfunc.h"
2. Indicando que se encuentran en el directorio por defecto del compilador.
#include <misfunc.h>

SALIDA / ENTRADA


Sentencia printf( )

La rutina printf permite la aparición de valores numéricos, caracteres y cadenas
de texto por pantalla.
El prototipo de la sentencia printf es el siguiente:
printf(control,arg1,arg2...);
En la cadena de control indicamos la forma en que se mostrarán los
argumentos posteriores. También podemos introducir una cadena de texto, sin
necesidad de argumentos, o combinar ambas posibilidades, así como
secuencias de escape.

11
En el caso de que utilicemos argumentos deberemos indicar en la cadena de
control tantos modificadores como argumentos vayamos a presentar.
El modificador está compuesto por el carácter % seguido por un carácter de
conversión, que indica de qué tipo de dato se trata.
Ejemplo:
/* Uso de la sentencia printf() 1. */
#include <stdio.h>
main() /* Saca por pantalla una suma */
{
int a=20,b=10;
printf("El valor de a es %dn",a);
printf("El valor de b es %dn",b);
printf("Por tanto %d+%d=%d",a,b,a+b);
}

Los modificadores más utilizados son:
%c
%d
%u
%o
%x
%e
%f
%s
%p

Un único carácter
Un entero con signo, en base decimal
Un entero sin signo, en base decimal
Un entero en base octal
Un entero en base hexadecimal
Un número real en coma flotante, con exponente
Un número real en coma flotante, sin exponente
Una cadena de caracteres
Un puntero o dirección de memoria

Ejemplo:
/* Uso de la sentencia printf() 2. */
#include <stdio.h>
main() /* Modificadores 1 */
{
char cad[]="El valor de";
int a=-15;
unsigned int b=3;

12
float c=932.5;
printf("%s a es %dn",cad,a);
printf("%s b es %un",cad,b);
printf("%s c es %e o %f",cad,c,c);
}
El formato completo de los modificadores es el siguiente:
% [signo] [longitud] [.precisión] [l/L] conversión
Signo: indicamos si el valor se ajustará a la izquierda, en cuyo caso
utilizaremos el signo menos, o a la derecha.
Longitud: especifica la longitud máxima del valor que aparece por pantalla. Si
la longitud es menor que el número de dígitos del valor, éste aparecerá
ajustado a la izquierda.
Precisión: indicamos el número máximo de decimales que tendrá el valor.
l/L: utilizamos l cuando se trata de una variable de tipo long y L cuando es de
tipo double.
Ejemplo:
/* Uso de la sentencia printf() 3. */
#include <stdio.h>
main() /* Modificadores 2 */
{
char cad[ ]="El valor de";
int a=25986;
long int b=1976524;
float c=9.57645;
printf("%s a es %9dn",cad,a);
printf("%s b es %ldn",cad,b);
printf("%s c es %.3f",cad,c);
}


Sentencia scanf( )

La rutina scanf permite entrar datos en la memoria del ordenador a través del
teclado.

13
El prototipo de la sentencia scanf es el siguiente:
scanf(control,arg1,arg2...);
En la cadena de control indicaremos, por regla general, los modificadores que
harán referencia al tipo de dato de los argumentos. Al igual que en la sentencia
printf los modificadores estarán formados por el carácter % seguido de un
carácter de conversión. Los argumentos indicados serán, nuevamente, las
variables.
La principal característica de la sentencia scanf es que necesita saber la
posición de la memoria del ordenador en que se encuentra la variable para
poder almacenar la información obtenida. Para indicarle esta posición
utilizaremos el símbolo ampersand &, que colocaremos delante del nombre de
cada variable. Esto no será necesario en los arrays.
Ejemplo:
/* Uso de la sentencia scanf(). */
#include <stdio.h>
main() /* Solicita dos datos */
{
char nombre[10];
int edad;
printf("Introduce tu nombre: ");
scanf("%s",nombre);
printf("Introduce tu edad: ");
scanf("%d",&edad);
}

SENTENCIAS CONDICIONALES
Este tipo de sentencias permiten variar el flujo del programa en base a unas
determinadas condiciones.
Existen varias estructuras diferentes:


Estructura IF...ELSE

Sintaxis:
if (condición) sentencia;
La sentencia solo se ejecuta si se cumple la condición. En caso contrario el
programa sigue su curso sin ejecutar la sentencia.

14
Otro formato:
if (condición) sentencia1;
else sentencia2;
Si se cumple la condición ejecutará la sentencia1, sinó ejecutará la sentencia2.
En cualquier caso, el programa continuará a partir de la sentencia2.
Ejemplo:
/* Uso de la sentencia condicional IF. */
#include <stdio.h>
main() /* Simula una clave de acceso */
{
int usuario,clave=18276;
printf("Introduce tu clave: ");
scanf("%d",&usuario);
if(usuario==clave)
printf("Acceso permitido");
else
printf("Acceso denegado");
}



Estructura SWITCH

Esta estructura se suele utilizar en los menús, de manera que según la opción
seleccionada se ejecuten una serie de sentencias.
Su sintaxis es:
switch (variable){
case contenido_variable1:
sentencias;
break;
case contenido_variable2:
sentencias;
break;
default:
sentencias;
}
15
Cada case puede incluir una o más sentencias sin necesidad de ir entre llaves,
ya que se ejecutan todas hasta que se encuentra la sentencia BREAK. La
variable evaluada sólo puede ser de tipo entero o caracter. default ejecutará las
sentencias que incluya, en caso de que la opción escogida no exista.
Ejemplo:
/* Uso de la sentencia condicional SWITCH. */
#include <stdio.h>
main() /* Escribe el día de la semana */
{
int dia;
printf("Introduce el día: ");
scanf("%d",&dia);
switch(dia){
case 1: printf("Lunes"); break;
case 2: printf("Martes"); break;
case 3: printf("Miércoles"); break;
case 4: printf("Jueves"); break;
case 5: printf("Viernes"); break;
case 6: printf("Sábado"); break;
case 7: printf("Domingo"); break;
}
}

BUCLES
Los bucles son estructuras que permiten ejecutar partes del código de forma
repetida mientras se cumpla una condición.
Esta condición puede ser simple o compuesta de otras condiciones unidas por
operadores lógicos.
 Sentencia WHILE
Su sintaxis es:
while (condición) sentencia;
16
Con esta sentencia se controla la condición antes de entrar en el bucle. Si ésta
no se cumple, el programa no entrará en el bucle.
Naturalmente, si en el interior del bucle hay más de una sentencia, éstas
deberán ir entre llaves para que se ejecuten como un bloque.
Ejemplo:
/* Uso de la sentencia WHILE. */
#include <stdio.h>
main() /* Escribe los números del 1 al 10 */
{
int numero=1;
while(numero<=10)
{
printf("%dn",numero);
numero++;
}
}

Sentencia DO...WHILE
Su sintaxis es:
do{
sentencia1;
sentencia2;
}while (condición);
Con esta sentencia se controla la condición al final del bucle. Si ésta se
cumple, el programa vuelve a ejecutar las sentencias del bucle.
La única diferencia entre las sentencias while y do-while es que con la
segunda el cuerpo del bucle se ejecutará por lo menos una vez.
Ejemplo:
/* Uso de la sentencia DO...WHILE. */
#include <stdio.h>¡
main() /* Muestra un menú si no se pulsa 4 */
{
char seleccion;
17
do{
printf("1.- Comenzarn");
printf("2.- Abrirn");
printf("3.- Grabarn");
printf("4.- Salirn");
printf("Escoge una opción: ");
seleccion=getchar();
switch(seleccion){
case '1':printf("Opción 1");
break;
case '2':printf("Opción 2");
break;
case '3':printf("Opción 3");
}
}while(seleccion!='4');
}

Sentencia FOR
Su sintaxis es:
for (inicialización;condición;incremento){
sentencia1;
sentencia2;
}
La inicialización indica una variable de control que condiciona la repetición del
bucle. Si hay más, van separadas por comas:
for (a=1,b=100;a!=b;a++,b- -){
El flujo del bucle FOR transcurre de la siguiente forma:

Ejemplo:
/* Uso de la sentencia FOR. */
#include <stdio.h>
main() /* Escribe la tabla de multiplicar */
{
18
int num,x,result;
printf("Introduce un número: ");
scanf("%d",&num);
for (x=0;x<=10;x++){
result=num*x;
printf("n%d por %d = %dn",num,x,result);
}
}

Sentencia BREAK
Esta sentencia se utiliza para terminar la ejecución de un bucle o salir de una
sentencia SWITCH.
Sentencia CONTINUE
Se utiliza dentro de un bucle. Cuando el programa llega a una sentencia
CONTINUE no ejecuta las líneas de código que hay a continuación y salta a la
siguiente iteración del bucle.
Y aquí termina el capítulo dedicado a los bucles. Existe otra sentencia, GOTO,
que permite al programa saltar hacia un punto identificado con una etiqueta,
pero el buen programador debe prescindir de su utilización. Es una sentencia
muy mal vista en la programación en 'C'.
Ejemplo:
/* Uso de la sentencia CONTINUE. */
#include <stdio.h>
main() /* Escribe del 1 al 100 menos el 25 */
{
int numero=1;
while(numero<=100)
{
if (numero==25)
{
numero++;

19
continue;
}
printf("%dn",numero);
numero++;
}
}

FUNCIONES
 Tiempo de vida de los datos
Según el lugar donde son declaradas puede haber dos tipos de variables.
Globales: las variables permanecen activas durante todo el programa. Se
crean al iniciarse éste y se destruyen de la memoria al finalizar. Pueden ser
utilizadas en cualquier función.
Locales: las variables son creadas cuando el programa llega a la función en la
que están definidas. Al finalizar la función desaparecen de la memoria.
Si dos variables, una global y una local, tienen el mismo nombre, la local
prevalecerá sobre la global dentro de la función en que ha sido declarada.
Dos variables locales pueden tener el mismo nombre siempre que estén
declaradas en funciones diferentes.
Ejemplo:
/* Variables globales y locales. */
#include <stdio.h>
int num1=1;
main() /* Escribe dos cifras */
{
int num2=10;
printf("%dn",num1);
printf("%dn",num2);
}

20
 Funciones
Las funciones son bloques de código utilizados para dividir un programa en
partes más pequeñas, cada una de las cuáles tendrá una tarea determinada.
Su sintaxis es:
tipo_función nombre_función (tipo y nombre de argumentos)
{
bloque de sentencias
}
Tipo función: puede ser de cualquier tipo de los que conocemos. El valor
devuelto por la función será de este tipo. Por defecto, es decir, si no indicamos
el tipo, la función devolverá un valor de tipo entero ( int ). Si no queremos que
retorne ningún valor deberemos indicar el tipo vacío ( void ).
Nombre función: es el nombre que le daremos a la función.
Tipo y nombre de argumentos: son los parámetros que recibe la función. Los
argumentos de una función no son más que variables locales que reciben un
valor. Este valor se lo enviamos al hacer la llamada a la función. Pueden existir
funciones que no reciban argumentos.
Bloque de sentencias: es el conjunto de sentencias que serán ejecutadas
cuando se realice la llamada a la función.
Las funciones pueden ser llamadas desde la función main o desde otras
funciones. Nunca se debe llamar a la función main desde otro lugar del
programa. Por último recalcar que los argumentos de la función y sus variables
locales se destruirán al finalizar la ejecución de la misma.



Declaración de las funciones

Al igual que las variables, las funciones también han de ser declaradas. Esto es
lo que se conoce como prototipo de una función. Para que un programa en C
sea compatible entre distintos compiladores es imprescindible escribir los
prototipos de las funciones.
Los prototipos de las funciones pueden escribirse antes de la función main o
bien en otro fichero. En este último caso se lo indicaremos al compilador
mediante la directiva #include.
En el ejemplo adjunto podremos ver la declaración de una función, prototipo. Al
no recibir ni retornar ningún valor, está declarada como void en ambos lados.
También vemos que existe una variable global llamada num. Esta variable es
reconocible en todas las funciones del programa. Ya en la función main
21
encontramos una variable local llamada num. Al ser una variable local, ésta
tendrá preferencia sobre la global. Por tanto la función escribirá los números 10
y 5.
Ejemplo:
/* Declaración de funciones. */
#include <stdio.h>
void funcion(void); /* prototipo */
int num=5; /* variable global */
main() /* Escribe dos números */
{
int num=10; /* variable local */
printf("%dn",num);
funcion(); /* llamada */
}
void funcion(void)
{
printf("%dn",num);
}


Paso de parámetros a una función

Las funciones pueden retornar un valor. Esto se hace mediante la instrucción
return, que finaliza la ejecución de la función, devolviendo o no un valor.
En una misma función podemos tener más de una instrucción return. La forma
de retornar un valor es la siguiente:
return ( valor o expresión );
El valor devuelto por la función debe asignarse a una variable. De lo contrario,
el valor se perderá.
En el ejemplo puedes ver lo que ocurre si no guardamos el valor en una
variable. Fíjate que a la hora de mostrar el resultado de la suma, en el printf,
también podemos llamar a la función.
Ejemplo:
/* Paso de parámetros. */
#include <stdio.h>
int suma(int,int); /* prototipo */
22
main() /* Realiza una suma */
{
int a=10,b=25,t;
t=suma(a,b); /* guardamos el valor */
printf("%d=%d",suma(a,b),t);
suma(a,b); /* el valor se pierde */
}
int suma(int a,int b)
{
return (a+b);
}

Paso de parámetros
Existen dos formas de enviar parámetros a una función:
Por valor: cualquier cambio que se realice dentro de la función en el
argumento enviado, NO afectará al valor original de las variables utilizadas en
la llamada. Es como si trabajáramos con una copia, no con el original. No es
posible enviar por valor arrays, deberemos hacerlo por referencia.
Por referencia: lo que hacemos es enviar a la función la dirección de memoria
donde se encuentra la variable o dato. Cualquier modificación SI afectará a las
variables utilizadas en la llamada. Trabajamos directamente con el original.
Ejemplo:
/* Paso por valor. */
#include <stdio.h>
void intercambio(int,int);
main() /* Intercambio de valores */
{
int a=1,b=2;
printf("a=%d y b=%d",a,b);
intercambio(a,b); /* llamada */
printf("a=%d y b=%d",a,b);
}
void intercambio (int x,int y)
{
int aux;
aux=x;
x=y;
23
y=aux;
printf("a=%d y b=%d",x,y);
}
Para enviar un valor por referencia se utiliza el símbolo &, ampersand, delante
de la variable enviada. Esto le indica al compilador que la función que se
ejecutará tendrá que obtener la dirección de memoria en que se encuentra la
variable.
Vamos a fijarnos en los ejemplos. En el ejemplo anterior podrás comprobar que
antes y después de la llamada, las variables mantienen su valor. Solamente se
modifica en la función intercambio-paso por valor.
En el siguiente ejemplo las variables intercambian su valor tras la llamada de la
función-paso por referencia.
Las variables con un * son conocidas como punteros, el único dato en 'C' que
puede almacenar una dirección de memoria.
Ejemplo:
/* Paso por referencia. */
#include <stdio.h>
void intercambio(int *,int *);
main() /* Intercambio de valores */
{
int a=1,b=2;
printf("a=%d y b=%d",a,b);
intercambio(&a,&b); /* llamada */
printf("a=%d y b=%d",a,b);
}
void intercambio (int *x,int *y)
{
int aux;
aux=*x;
*x=*y;
*y=aux;
printf("a=%d y b=%d",*x,*y);
}

24
Los argumentos de la función main:
La función main no podía ser menos y también puede recibir argumentos, en
este caso desde el exterior.
Los argumentos que puede recibir son:
argc: es un contador. Su valor es igual al número de argumentos escritos en la
línea de comandos, contando el nombre del programa que es el primer
argumento.
argv: es un puntero a un array de cadenas de caracteres que contiene los
argumentos, uno por cadena.
En este ejemplo vamos a ver un pequeño programa que escribirá un saludo por
pantalla. El programa FUNCION6.EXE.
Ejemplo:
/* Argumentos de la main. */
#include <stdio.h>
main(int argc,char *argv[]) /* argumentos */
{
printf("nCurso de Programación en C - Copyright (c) 1997-2001,
Sergio Pachon");
printf("Programa de ejemplo.nn");
if (argc<2)
{
printf("Teclee: funcion6 su_nombre");
exit(1); /* fin */
}
printf("Hola %s",argv[1]);
}

VECTORES
Un vector es un array unidimensional, es decir, sólo utiliza un índice para
referenciar a cada uno de los elementos. Un array es un identificador que
referencia un conjunto de datos del mismo tipo. Imagina un tipo de dato int;
podremos crear un conjunto de datos de ese tipo y utilizar uno u otro con sólo
cambiar el índice que lo referencia. El índice será un valor entero y positivo. En
C los arrays comienzan por la posición 0.
25
Su declaración será:
tipo nombre [tamaño];
El tipo puede ser cualquiera de los ya conocidos y el tamaño indica el número
de elementos del vector, se debe indicar entre corchetes [ ]. En el ejemplo
puedes observar que la variable i es utilizada como índice, el primer for sirve
para rellenar el vector y el segundo para visualizarlo. Como ves, las posiciones
van de 0 a 9, total 10 elementos.
Ejemplo:
/* Declaración de un array. */
#include <stdio.h>
main() /* Rellenamos del 0 - 9 */
{
int vector[10],i;
for (i=0;i<10;i++) vector[i]=i;
for (i=0;i<10;i++) printf(" %d",vector[i]);
}
Podemos inicializar, asignarle valores un vector en el momento de declararlo.
Si lo hacemos así no es necesario indicar el tamaño.
Su sintaxis es:
tipo nombre []={ valor 1, valor 2...}
Ejemplos:
int vector[ ]={1,2,3,4,5,6,7,8};
char vector[ ]="programador";
char vector[ ]={'p','r','o','g','r','a','m','a','d','o','r'};
Una particularidad con los vectores de tipo char, cadena de caracteres, es que
deberemos indicar en que elemento se encuentra el fin de la cadena mediante
el carácter nulo (0). Esto no lo controla el compilador, y tendremos que ser
nosotros los que insertemos este carácter al final de la cadena.
Por tanto, en un vector de 10 elementos de tipo char podremos rellenar un
máximo de 9, es decir, hasta vector[8]. Si sólo rellenamos los 5 primeros, hasta
vector[4], debemos asignar el carácter nulo a vector[5]. Es muy sencillo:
vector[5]='0'; .

26
Ejemplo de cómo se rellena un vector de tipo char.
/* Vector de tipo char. */
#include <stdio.h>
main() /* Rellenamos un vector char */
{
char cadena[20];
int i;
for (i=0;i<19 && cadena[i-1]!=13;i++)
cadena[i]=getche( );
if (i==19) cadena[i]='0';
else cadena[i-1]='0';
printf("n%s",cadena);
}
Podemos ver que en el for se encuentran dos condiciones:
1.- Que no se hayan rellenado todos los elementos (i<19).
2.- Que el usuario no haya pulsado la tecla ENTER, cuyo código ASCII
es 13. (cadena[x-i]!=13).
También podemos observar una nueva función llamada getche( ), que se
encuentra en conio.h. Esta función permite la entrada de un carácter por
teclado. Después se encuentra un if, que comprueba si se ha rellenado todo el
vector. Si es cierto, coloca el carácter nulo en el elemento nº20 (cadena[19]).
En caso contrario tenemos el else, que asigna el carácter nulo al elemento que
almacenó el carácter ENTER.
En resumen: al declarar una cadena deberemos reservar una posición más que
la longitud que queremos que tenga dicha cadena.

Llamadas a funciones con arrays
Como ya se comentó en el tema anterior, los arrays únicamente pueden ser
enviados a una función por referencia. Para ello deberemos enviar la dirección
de memoria del primer elemento del array. Por tanto, el argumento de la
función deberá ser un puntero.
Ejemplo:
/* Envío de un array a una función. */
#include <stdio.h>
void visualizar(int []); /* prototipo */
main() /* rellenamos y visualizamos */
{
int array[25],i;
27
for (i=0;i<25;i++)
{
printf("Elemento nº %d",i+1);
scanf("%d",&array[i]);
}
visualizar(&array[0]);
}
void visualizar(int array[]) /* desarrollo */
{
int i;
for (i=0;i<25;i++) printf("%d",array[i]);
}
En el ejemplo se puede apreciar la forma de enviar un array por referencia. La
función se podía haber declarado de otra manera, aunque funciona
exactamente igual:
declaración o prototipo
void visualizar(int *);
desarrollo de la función
void visualizar(int *array)

MATRICES
Una matriz es un array multidimensional. Se definen igual que los vectores
excepto que se requiere un índice por cada dimensión.
Su sintaxis es la siguiente:
tipo nombre [tamaño 1][tamaño 2]...;
Una matriz bidimensional se podría representar gráficamente como una tabla
con filas y columnas.
La matriz tridimensional se utiliza, por ejemplo, para trabajos gráficos con
objetos 3D.
En el ejemplo puedes ver como se rellena y visualiza una matriz bidimensional.
Se necesitan dos bucles para cada una de las operaciones. Un bucle controla
las filas y otro las columnas.
28
Ejemplo:
/* Matriz bidimensional. */
#include <stdio.h>
main() /* Rellenamos una matriz */
{
int x,i,numeros[3][4];
/* rellenamos la matriz */
for (x=0;x<3;x++)
for (i=0;i<4;i++)
scanf("%d",&numeros[x][i]);
/* visualizamos la matriz */
for (x=0;x<3;x++)
for (i=0;i<4;i++)
printf("%d",numeros[x][i]);
}

Si al declarar una matriz también queremos inicializarla, habrá que tener en
cuenta el orden en el que los valores son asignados a los elementos de la
matriz.
Ejemplos:
int numeros[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
quedarían asignados de la siguiente manera:
numeros[0][0]=1 numeros[0][1]=2

numeros[0][2]=3

numeros[0][3]=4
numeros[1][0]=5 numeros[1][1]=6

numeros[1][2]=7

numeros[1][3]=8
numeros[2][0]=9 numeros[2][1]=10 numeros[2][2]=11
numeros[2][3]=12

También se pueden inicializar cadenas de texto:
char
dias[7][10]={"lunes","martes","miércoles","jueves","viernes","sábado","domingo"
};
29
Para referirnos a cada palabra bastaría con el primer índice:
printf("%s",dias[i]);


PUNTEROS

Un puntero es una variable que contiene la dirección de memoria de otra
variable. Se utilizan para pasar información entre una función y sus puntos de
llamada.

Declaración
Su sintaxis es la siguiente:
tipo *nombre;
Donde nombre es, naturalmente, el nombre de la variable, y tipo es el tipo del
elemento cuya dirección almacena el puntero.

Operadores
Existen dos operadores especiales para trabajar con punteros: & y *.
El primero devuelve la dirección de memoria de su operando. Por ejemplo, si
queremos guardar en el puntero x la dirección de memoria de la variable num,
deberemos hacer lo siguiente:
x=#
El segundo devuelve el valor de la variable cuya dirección es contenida por el
puntero. Este ejemplo sitúa el contenido de la variable apuntada por x, es decir
num, en la variable a:
a=*x;
Asignación
Los punteros se asignan igual que el resto de las variables. El programa
ejemplo mostrará las direcciones contenidas en p1 y p2, que será la misma en
ambos punteros.
Ejemplo:
/* Asignaciones de punteros. */
#include <stdio.h>
main() /* Asignamos direcciones */
{
int a;
int *p1,*p2;
30
p1=&a;
p2=p1;
printf("%p %p",p1,p2);
}
Aritmética de direcciones
Es posible desplazar un puntero recorriendo posiciones de memoria. Para ello
podemos usar los operadores de suma, resta, incremento y decremento (+, -,
++, - -). Si tenemos un puntero ( p1 ) de tipo int ( 2 bytes ), apuntando a la
posición 30000 y hacemos: p1=p1+5; el puntero almacenará la posición 30010,
porque apunta 5 enteros por encima ( 10 bytes más ).

Concepto de estructura
Una estructura es un conjunto de una o más variables, de distinto tipo,
agrupadas bajo un mismo nombre para que su manejo sea más sencillo.
Su utilización más habitual es para la programación de bases de datos, ya que
están especialmente indicadas para el trabajo con registros o fichas.
La sintaxis de su declaración es la siguiente:
{
tipo_variable nombre_variable1;
tipo_variable nombre_variable2;
tipo_variable nombre_variable3;
};
Donde tipo-estructura es el nombre del nuevo tipo de dato que hemos creado.
Por último, tipo-variable y nombre-variable son las variables que forman parte
de la estructura.
Para definir variables del tipo que acabamos de crear lo podemos hacer de
varias maneras, aunque las dos más utilizadas son éstas:

Una forma de definir la estructura:
struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;
31
char puesto[10];
};
struct trabajador fijo, temporal;
Otra forma:
struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;
char puesto[10];
}fijo, temporal;
En el primer caso declaramos la estructura, y en el momento en que
necesitamos las variables, las declaramos. En el segundo las declaramos al
mismo tiempo que la estructura. El problema del segundo método es que no
podremos declarar más variables de este tipo a lo largo del programa. Para
poder declarar una variable de tipo estructura, la estructura tiene que estar
declarada previamente. Se debe declarar antes de la función main.
El manejo de las estructuras es muy sencillo, así como el acceso a los campos
o variables de estas estructuras. La forma de acceder a estos campos es la
siguiente:
variable.campo;
Donde variable es el nombre de la variable de tipo estructura que hemos
creado, y campo es el nombre de la variable que forma parte de la estructura.
Lo veremos mejor con un ejemplo basado en la estructura definida
anteriormente:
temporal.edad=25;
Almacena el valor 25 en el campo edad de la variable temporal de tipo
trabajador.
Otra característica interesante de las estructuras es que permiten pasar el
contenido de una estructura a otra, siempre que sean del mismo tipo
naturalmente:
fijo=temporal;
Al igual que con los otros tipos de datos, también es posible inicializar variables
de tipo estructura en el momento de su declaración:

32
struct trabajador fijo={"Pedro","Hernández Suárez", 32, "gerente"};
Si uno de los campos de la estructura es un array de números, los valores de la
inicialización deberán ir entre llaves:
struct notas
{
char nombre[30];
int notas[5];
};
struct notas alumno={"Carlos Pérez",{8,7,9,6,10}};

LIBRERÍAS
Librería stdio.h
printf
Función: Escribe en la salida estándar con formato.
Sintaxis: printf(formato , arg1 , ...);
scanf
Función: Lee de la salida estándar con formato.
Sintaxis: scanf(formato , arg1 , ...);
puts
Función: Escribe una cadena y salto de linea.
Sintaxis: puts(cadena);
gets
Función: Lee y guarda una cadena introducida por teclado.
Sintaxis: gets(cadena);
fopen
Función: Abre un fichero en el modo indicado.
Sintaxis: pf=fopen(fichero , modo);
fclose
Función: Cierra un fichero cuyo puntero le indicamos.
Sintaxis: fclose(pf);
fprintf
Función: Escribe con formato en un fichero.
Sintaxis: fprintf(pf , formato , arg1 , ...);
fgets
33
Función: Lee una cadena de un fichero.
Sintaxis: fgets(cadena , longitud , pf);

Librería stdlib.h
atof
Función: Convierte una cadena de texto en un valor de tipo float.
Sintaxis: numflo=atof(cadena);
atoi
Función: Convierte una cadena de texto en un valor de tipo entero.
Sintaxis: nument=atoi(cadena);
itoa
Función: Convierte un valor numérico entero en una cadena de texto. La
base generalmente será 10, aunque se puede indicar otra distinta.
Sintaxis: itoa(número , cadena , base);
exit
Función: Termina la ejecución y abandona el programa.
Sintaxis: exit(estado); /* Normalmente el estado será 0 */

Librería conio.h
clrscr
Función: Borra la pantalla.
Sintaxis: clrscr( );
clreol
Función: Borra desde la posición del cursor hasta el final de la linea.
Sintaxis: clreol( )
gotoxy
Función: Cambia la posición del cursor a las coordenadas indicadas.
Sintaxis: gotoxy(columna , fila);
textcolor
Función: Selecciona el color de texto (0 - 15).
Sintaxis: textcolor(color);
textbackground
Función: Selecciona el color de fondo (0 - 7).
Sintaxis: textbackground(color);
wherex
Función: Retorna la columna en la que se encuentra el cursor.
34
Sintaxis: col=wherex( );
wherey
Función: Retorna la fila en la que se encuentra el cursor.
Sintaxis: fila=wherey( );
getch
Función: Lee y retorna un único caracter introducido mediante el teclado por
el usuario. No muestra el caracter por la pantalla.
Sintaxis: letra=getch( );

Librería string.h
strlen
Función: Calcula la longitud de una cadena.
Sintaxis: longitud=strlen(cadena);
strcpy
Función: Copia el contenido de una cadena sobre otra.
Sintaxis: strcpy(copia , original);
strcat
Función: Concatena dos cadenas.
Sintaxis: strcat(cadena1 , cadena2);
strcmp
Función: Compara el contenido de dos cadenas. Si cadena1 < cadena2
retorna un número negativo. Si cadena1 > cadena2, un número positivo, y si
cadena1 es igual que cadena2 retorna 0 ( o NULL ).
Sintaxis: valor=strcmp(cadena1 , cadena2);

35
FUNDAMENTOS DE PROGRAMACIÓN
Programa.- Conjunto de sentencias ordenadas secuencialmente para generar
procesos automáticos.

Datos de
entrada

ELEMENTOS
DE UN
PROGRAMA
Resultados o
Datos de
salida

Procesos

Lenguaje de Programación.- Sintaxis que permite generar instrucciones para
desarrollar aplicaciones.

Librerías
Palabras
reservadas

Identificadores

ELEMENTOS DE
UN LENGUAJE DE
PROGRAMACIÓN

36
PARTES DE UN PROGRAMA
 Librerías.- Es una colección de clases y funciones, escritas en el núcleo del
lenguaje.
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include<math.h>



Variables.- son un tipo de dato, referenciado mediante un identificador
llamado de la variable. Su contenido podrá ser modificado a lo largo del
programa.

int op, j, a, b, c, d, v;
float c, v, vt, s, su ,total;
char p[15];
 Función main.- Indica el comienzo del programa y requiere los paréntesis ( )
a continuación de main( ) o void main ().
main ()
{
viod main ()
{
 Función clrscr.- Limpia la pantalla.

clrscr();
 Impresión de dados.

gotoxy(15,2);printf("SUMA DE DOS NUMEROS");
gotoxy(15,14);printf("Eltotal de la suma es = %d ",c);


Lectura de variables.- Lee cualquier carácter, numero o símbolo incrasado
desde teclado.

gotoxy(6,6);printf("Ingrese un número: ");scanf("%d",&a);
gotoxy(6,8);printf("Ingrese otro número: ");scanf("%d",&b);


Funciones.- Las funciones son bloques de código utilizados para dividir un
programa en partes más pequeñas, cada una de las cuáles tendrá una tarea
determinada.
37
void nun ( )
{
if(a>b && a>c)
{
gotoxy(16,14);printf("%d",a);
}
else
{
if(b<a && b>c)
{
gotoxy(16,15);printf("%d",b);
}
else
{
gotoxy(16,16);printf("%d",c);
}
}
}
nun ();


Estructura SWITCH.- Esta estructura se suele utilizar en los menús, de manera
que según la opción seleccionada se ejecuten una serie de sentencias.
switch(op)
{
case 1:
break;
case 2:
break;
case 5:
exit;
break;
}
 Procesos.- Suma, resta, multiplicación, división, potencia, radicación.
p=r*t;
total=r/2.3
 Sentencia do while.- Proceso de repetición.
do
{
}while (op==1)

38


Sentencias “for” para realizar el borde.

for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}


getch.- Esperar a que el usuario presione una tecla para saltar a la siguiente
instruccion o finalizar el programa si es que ya no quedan sentencias.

getche();


Sentencia IF...ELSE.- solo se ejecuta si se cumple la condición. En
caso contrario el programa sigue su curso sin ejecutar la sentencia.

if(d>=7)
{
gotoxy(6,15);printf("Aprobado");
}
else
{
gotoxy(6,15);printf("Suspenso");
}

 return.- es una sentencia la cual tiene como finalidad indicarle al compilador
que tiene que regresar el valor de retorno que tú le indiques.

return(0);

39
Programa Nº1
 Diseñe un programa que me permita ingresar un número entero desde teclado
de 1 a 7, y q me visualice el nombre del día de la semana que me corresponda.
Análisis.- Utilizamos una variable de tipo entera para ingresar por teclado, la sentencia
do-while para regresar si el número un no está entre 1-7, un swich para las opciones de
los siete días e imprimimos por pantalla el día correspondiente según el número
ingresado.
DOCUMENTACION
#include<stdio.h>
#include<conio.h>
int a;
main ()
{
clrscr();
gotoxy(25,3);printf("DIAS DE LA SEMANA");
do
{
gotoxy(29,5);printf(" ");
gotoxy(10,5);printf("Ingrese un número: ");scanf("%d",&a);
}while(a<1 || a>7);
switch(a)
{
case 1:
gotoxy(10,7);printf("Lunes");
break;
case 2:
gotoxy(10,7);printf("Martes");
break;
case 3:
gotoxy(10,7);printf("Miercoles");
break;
case 4:
gotoxy(10,7);printf("Jueves");
break;
case 5:
gotoxy(10,7);printf("Viernes");
break;
case 6:
gotoxy(10,7);printf("Sábado");
break;
case 7:
gotoxy(10,7);printf("Domingo");
break;
}
40

LIBRERIAS
VARIABLES
INICIO

LECTURA DE
VARIABLES

SENTENCIA SWICH
FIN

getch();
}

CORRIDO DEL PROGRAMA

41
Programa Nº2
 Diseñe un programa que me permita ingresar 2 números por teclado y realizar la
suma de los mismos
Análisis.- Utilizamos tres variables de tipo entero, las dos para ingresar por teclado
y la otra para realizar la suma, e imprimimos el resultado por pantalla.
DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
int a,b,c;
main ()
{
clrscr();
gotoxy(15,2);printf("SUMA DE DOS NUMEROS");
gotoxy(6,6);printf("Ingrese un número: ");scanf("%d",&a);
gotoxy(6,8);printf("Ingrese otro número: ");scanf("%d",&b);
c=a+b;
gotoxy(15,14);printf("Eltotal de la suma es = %d ",c);
getche();
return(0);
}

42

LIBRERIAS
VARIABLES

INICIO

LECTURA DE
VARIABLES

FIN
CORRIDO DEL PROGRAMA

Programa Nº3
 Diseñe un programa que me permita ingresar 3 números 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
Análisis.- Utilizamos cuatro variables de tipo enteras, un do-wille para que las notas
solo sean de 1-10, realizamos los procesos e imprimimos el resultado.
DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
int a,b,c,d;
main ()
{
clrscr();
gotoxy(15,2);printf("PROMEDIO");
do
{
gotoxy(30,6);printf(" ");
gotoxy(6,6);printf("Ingrese la primera nota: ");scanf("%d",&a);
}while(a<0 || a>10);
do
{
gotoxy(30,8);printf(" ");
gotoxy(6,8);printf("Ingrese la segunda nota: ");scanf("%d",&b);
43

LIBRERIAS
VARIABLES
INICIO

LECTURA DE
VARIABLES
}while(b<0 || b>10);
do
{
gotoxy(30,10);printf(" ");
gotoxy(6,10);printf("Ingrese la tercera nota: ");scanf("%d",&c);
}while (c<0 || c>10);
d=(a+b+c)/3;
gotoxy(6,14);printf("Promedio %d",d);
if(d>=7)
{
gotoxy(6,15);printf("Aprobado");
}
else
{
if(d>=5&&d<7)
{
gotoxy(6,15);printf("Suspenso");
}
else
{
if(c<5)
{
gotoxy(6,15);printf("Reprobado"); }}
}
getche();
return(0);
}

CORRIDO DEL PROGRAMA
44

LECTURA DE
VARIABLES

CONDICIONAL “IF”

FIN
45
Programa Nº4
 Diseñe un programa que realice la suma de dos números, siempre que el
primer valor este entre 3 y 23 y el segundo valor este entre 5 y 17.
Análisis.- Utilizamos tres variables de tipo enteras, dos do-while para que cumpla la
condición requerida, realizamos el proceso y presentamos resultados
DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
int a,b,c;
main ()
{
clrscr();
gotoxy(15,2);printf("SUMA DE DOS NUMEROS");
do
{
gotoxy(23,6);printf(" ");
gotoxy(6,6);printf("Ingrese un n£mero: ");scanf("%d",&a);
}while (a<3 || a>23);
do
{
gotoxy(23,8);printf(" ");
gotoxy(6,8);printf("Ingrese otro n£mero: ");scanf("%d",&b);
}while (b<5 || b>17);
c=a+b;
gotoxy(15,14);printf("Eltotal de la suma es = %d ",c);
getche();
return(0);
}

CORRIDO DEL PROGRAMA
46

LIBRERIAS
VARIABLES
INICIO

LECTURA DE
VARIABLES

FIN
Programa Nº5
 Diseñe 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.
DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
main ()
{
int a=1,b=0,oper;
float c,p,v,s,t,f,g,r,q;
do
{
clrscr();
a=1;
b=0;
gotoxy(30,2);printf("COMISIONES DE VENTAS");
gotoxy(5,5);printf("Ingresar el valor de la venta:");scanf("%f",&c);
if((c>2999)&&(c<5001))
{
p=(c*5)/100;
v=c+p;
gotoxy(8,10);printf("La venta total es=%f",v);
gotoxy(8,13);printf("La ganancia es=%f",p);
}
if((c>5000)&&(c<8499))
47

LIBRERIAS
VARIABLES
INICIO

LECTURA DE
VARIABLES
{
s=(c*7)/100;
t=s+c;
gotoxy(8,10);printf("La venta total es=%f",t);
gotoxy(8,13);printf("La ganancia es=%f",s);
}
if((c>8500)&&(c<10001))
{
r=(c*8)/100;
q=r+c;
gotoxy(8,10);printf("La venta total es=%f",q);
gotoxy(8,13);printf("La ganancia es=%f",r);
}
if(c>10000)
{
f=(c*10)/100;
g=f+c;
gotoxy(8,10);printf("La venta total es=%f",g);
gotoxy(8,13);printf("La ganancia es=%f",f);
}
gotoxy(30,20);printf("PRESS 1 para continuar o 0 abandonar");
scanf("%d",&oper);
}
while(oper==1);
getch();
}

CORRIDO DEL PROGRAMA

48

SENTECIA “IF”

FIN
Programa Nº6
 Diseñe 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 niño”
 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.

Análisis.- Utilizamos tres variables, una de tipo entera y otra de tipo carácter,
sentencias if-else para realizar las equivalencias requeridas y un do-while para
repetir el proceso.
DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
int ed,op;
char nombre[15];
do
{
clrscr();
gotoxy(31,1);printf("Saber edad y equivalencia");
flushall();
gotoxy(10,3);printf("Ingrese nombre: ");gets(nombre);
49

LIBRERIAS
VARIABLES
INICIO

LECTURA DE
VARIABLES
do
{
gotoxy(27,4);printf(" ");
gotoxy(10,4);printf("Ingrese la edad: ");scanf("%d",&ed);
}while(ed>85 || ed<3);
if(ed>=3 && ed<=5)
{
gotoxy(10,7);printf("Es un bebe");
}
else
{
if(ed>5 && ed<=13)
SENTECIA “IF”
{
gotoxy(10,7);printf("Ni¤o");
}
else
{
if(ed>15 && ed<=21)
{
gotoxy(10,7);printf("Adolecente");
}
else
{
if(ed>21 && ed<=61)
{
gotoxy(10,7);printf("Adulto");
}
else
{
gotoxy(10,7);printf("Adulto Mayor");
}
}
}
}
gotoxy(10,6);puts(nombre);
gotoxy(10,10);printf("Presione 1 para continuar o 0 para salir: ");scanf("%d",&op);
}while(op==1);
getch();
FIN
}

}

50
CORRIDO DEL PROGRAMA

51
Programa Nº7
 Diseñe 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 según los productos que el usuario desee ingresar.
Análisis.- Utilizamos 15 variables de tipo enteras, decimales y de caracte, un dowhile para que se repita el proceso, realizamos el proceso y presentamos
resultados.
DOCUMENTACIÓN
LIBRERIAS
#include<stdio.h>
#include<conio.h>
VARIABLES
main()
{
INICIO
int op,j,a=4,b=4,c=4,d=4,v=0;
float cant,vuni,vtotal,iva,s,sub,totalp;
char p[15];
clrscr();
gotoxy(23,1); printf("SIMULACION DE FACTURA");
gotoxy(5,4); printf("Producto");
IMPRESION
gotoxy(20,4); printf("Cantidad");
gotoxy(34,4); printf("Precio Unitario");
gotoxy(55,4); printf("Valor");
do
{
flushall();
a=a+1;gotoxy(5,a);gets(p);
b=b+1;gotoxy(23,b);scanf("%2f",&cant);
OPERASIONES
c=c+1;gotoxy(39,c);scanf("%2f",&vuni);
vtotal=cant*vuni;
d=d+1;gotoxy(55,d);printf("%.2f",vtotal);
v=v+vtotal;
LECTURA DE
gotoxy(2,24);printf("presione 1 para ingresar otro producto o 0 para
finalizar la factura: ");scanf("%d",&op);
}while(op==1);
j=v;
sub=j;
gotoxy(45,21); printf("subtotal: %.2f",sub);
iva=(sub*12)/100;
IMPRESION
gotoxy(50,22); printf("iva: %.2f",iva);
vtotal=sub+iva;
gotoxy(40,23); printf("valor a pagar: %.2f",vtotal);
getch();
FIN
}

52
CORRIDO DEL PROGRAMA

53
Programa Nº8
 Diseñe un programa que me permita calcular el promedio general de
las notas de distintas materias correspondientes al 2do semestre de
docencia en informática, en donde cada uno de las notas ingresadas
debe estar entre 1 y 10.
Análisis.- Utilizamos 6 variables de tipo enteras y decimales realizamos los
procesos e imprimimos por pantalla.
DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
main()
{
int c=5,n1,n2,n3,op;
float prom;
clrscr();
gotoxy(27,2);printf("Facultad de Ciencias Humanas");
gotoxy(30,3);printf("Segundo Informatica");
gotoxy(8,5); printf("Modulos nota 1nota 2 nota 3promedio");
gotoxy(5,6); printf("Programacion 1");
gotoxy(5,7); printf("Fisica 2");
gotoxy(5,8); printf("Matematica Basica");
gotoxy(5,9); printf("M. de la Investigacion");
gotoxy(5,10);printf("Trabajo en Equipo");
gotoxy(5,11);printf("Realidad Nacional");
gotoxy(5,12);printf("Ntics");
do
{
c=c+1;
do
{
gotoxy(39,c);printf(" ");
gotoxy(39,c);scanf("%d",&n1);
}
while (n1>10);
do
{
gotoxy(49,c);printf(" ");
gotoxy(49,c);scanf("%d",&n2);
}
while (n2>10);
do
{
gotoxy(60,c);printf(" ");
gotoxy(60,c);scanf ("%d",&n3);
54

LIBRERIAS
VARIABLES
INICIO

IMPRESION

SENTECIA “IF”
}
while (n3>10);
prom=(n1+n2+n3)/3;
gotoxy(70,c);printf("%.2f",prom);
gotoxy(5,15);printf("presione 1 para continuar o 0 para salir");scanf("%d",&op);
}
while (op==1);
getch();
FIN
}

55
CORRIDO DEL PROGRAMA

Programa Nº9
 Realice un programa en C++ que me permita obtener el líquido a recibir
de un empleado bajo los siguientes parámetros:
El empleado percibe un salario mínimo vital el mismo que depende de su
categoría, existen 3 posibles alternativas, este dato deberá ser ingresada al
inicio del programa conjuntamente con el nombre del empleado:
 Categoría 1
180,00
 Categoría 2
250,00
 Categoría 3
380,00
A este salario mínimo 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 esta condicionada. Si el empleado tiene mas
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 asociación
5. Obtenga los valores correspondientes de ingresos, egresos y total a
recibir
El programa se genera n veces.

56
Análisis.- Utilizamos variables de tipo enteras, decimales y de carácter, dowhile para repetir el proceso, if para que cumpla las condiciones requeridas,
realizamos los proceso e imprimimos el resultado por pantalla.
DOCUMENTACIÓN
#include<stdio.h>
LIBRERIAS
#include<conio.h>
main ()
VARIABLES
{
floatx=180,y=250,z=380,s,iess,i=11.5,dcto,a=2,p=1.80,ex,hex,j=4.50,k=6.20,
INICIO
b,in,eg,t;
int c,h,op;
char n[50];
do
{
flushall();
clrscr();
gotoxy(31,3); printf("INGRESO DE DATOS");
gotoxy(2,5); printf("Ingrese su nombre: ");flushall(); gets(n);
do
{
gotoxy(2,8); printf("Escoja su categoria: 1, 2 o 3: "); scanf("%d",&c);
}
while(c>3 || c<1);
gotoxy(2,11); printf("Cantidad de hijos registrados: "); scanf("%d",&h);
do
{
gotoxy(2,14);printf("Horas extras registradas: "); scanf("%f",&hex);
}
while(hex<1 || hex>8);
clrscr();
gotoxy(5,3); printf("********************ROL DE PAGOS********************");
gotoxy(5,5); printf("Empleado: %s",n);
gotoxy(5,6); printf("Corresponde: Septiembre 2013");
gotoxy(5,7); printf("Dias laborados: 30 dias");
gotoxy(5,8); printf("**************************");
gotoxy(10,10); printf("Ingresos");
LECTURA DE
gotoxy(46,10); printf("Egresos");
gotoxy(5,12); printf("Sueldo nominal ");
if(c==1)
{
s=x;
gotoxy(21,12); printf("%.2f",s);
}
if(c==2)
{
s=y;
gotoxy(21,12); printf("%.2f",s);
}
57
if(c==3)
{
s=z;
gotoxy(21,12); printf("%.2f",s);
}
iess=(s*i)/100;
gotoxy(38,12); printf("Seguro: ");
gotoxy(52,12); printf("%.2f",iess);
dcto=(s*a)/100;
gotoxy(38,13); printf("Dcto. Asoc.: ");
gotoxy(52,13); printf("%.2f",dcto);
ex=(hex*p);
gotoxy(5,13); printf("Horas extras: ");
gotoxy(21,13);printf("%.2f",ex);
gotoxy(5,14); printf("Bono Familiar: ");
if (h>2)
{
b=(h*j);
gotoxy(21,14);printf("%.2f",b);
}
if (h<3)
{
b=(h*k);
gotoxy(21,14);printf("%.2f",b);
}
in=(s+ex+b);
gotoxy(5,18); printf("Total Ingresos: ");
gotoxy(21,18);printf("%.2f",in);
eg=(iess+dcto);
gotoxy(38,18);printf("Total Egresos: ");
gotoxy(52,18);printf("%.2f",eg);
t=(in-eg);
gotoxy(38,24);printf("TOTAL A RECIBIR: ");
gotoxy(55,24);printf("%.2f",t);
gotoxy(37,23);printf("*************************");
gotoxy(37,25);printf("*************************");
gotoxy(5,23); printf("presione 1 para regresar o ");
gotoxy(5,24); printf("presione 0 para salir: ");
scanf("%d",&op);
}
while (op==1);
getch();
}

58

IMPRESION

IMPRESION

FIN
59
CORRIDO DEL PROGRAMA

60
Programa Nº10
 Diseñe un programa que me permita imprimir un borde de pantalla.
Análisis.- Utilizamos una variable de tipo entera y un ciclo for para imprimir
el borde.
DOCUMENTACIÓN
LIBRERIAS

#include<stdio.h>
#include<conio.h>
main()
{
int i,limite,fila=6,op;
fila=6;
clrscr();
for (i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for (i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
getch();
}

VARIABLES
INICIO

SENTENCIA “FOR”

FIN

61
CORRIDO DEL PROGRAMA

Programa Nº11
 Diseñe un programa que me permita visualizar la serie de los
números pares y los impares que existen hasta el número límite
ingresado desde teclado.
Análisis.- Utilizamos 4 variables de tipo entera, realizamos el proceso y
presentamos resultados
DOCUMENTACIÓN
LIBRERIAS

#include<stdio.h>
#include<conio.h>
main()
{
int i,limite,fila=6,op;
do
{
fila=6;
clrscr();
for (i=1;i<=80;i++)

VARIABLES
INICIO

62
{
gotoxy(i,1);printf("*");

gotoxy(i,24);printf("*");
}
SENTENCIA “FOR”
for (i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
gotoxy(5,2);printf("ingrese el limite: ");scanf("%d",&limite);
gotoxy(20,4);printf("Pares:");
for (i=2;i<=limite;i+=2)
{
gotoxy(23,fila);printf("%d",i);
fila=fila+1;
}
SENTENCIA “FOR”
fila=6;
gotoxy(42,4);printf("Impares:");
for (i=1;i<=limite;i+=2)
{
gotoxy(46,fila);printf("%d",i);
fila=fila+1;
}
gotoxy(60,21);printf("presione:");
gotoxy(60,22);printf("1 para continuar");
gotoxy(60,23);printf("0 para salir: "); scanf("%d",&op);
}
while(op==1);
getch();
}

FIN

63
CORRIDO DEL PROGRAMA

64
Programa Nº612
 Realizar un programa y visualizar los números primos.
Análisis.- Activamos la librerías, utilizamos variables de tipo enteras, dowhile para que cumpla la condición requerida, realizamos el proceso y
presentamos resultados
DOCUMENTACIÓN
LIBRERIAS

#include<stdio.h>
#include<conio.h>
#include<string.h>
main()
{
int i, j, fla=7, lim, cnt=0, resul, op;
do
{
fla=7;
clrscr();
gotoxy(35,3);printf("NUMEROS PRIMOS");
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
gotoxy(5,8);printf("ingrese limite: ");scanf("%d",&lim);
for(i=1;i<=lim;i++)
{
cnt=0;
for(j=1;j<=i;j++)
{
resul=i%j;
if(resul==0)
{
cnt=cnt+1;
}
}
if(cnt==2)
{
gotoxy(40,fla);printf("%d",i);
fla=fla+1;
}
}

65

VARIABLES
INICIO

SENTENCIA “FOR”

SENTENCIA “FOR”
CORRIDO DEL PROGRAMA

Programa Nº13
 Diseñe un programa que me permita visualizar la factorial de un número
ingresado desde teclado.
Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la
condición requerida, sentencias for y realizamos los proceso y presentamos
resultados.
DOCUMENTACIÓN
LIBRERIAS

#include<stdio.h>
#include<conio.h>
main()
{
int i,j,m,l,f=1,op;
do
{
clrscr();
f=1;
//borde de pantalla
m=10;
for (i=1;i<=80;i++)
{
gotoxy(i,1); printf("*");
gotoxy(i,24);printf("*");
}

VARIABLES
INICIO

SENTENCIA “FOR”

66
for (i=1;i<=24;i++)
{
gotoxy(1,i); printf("*");
gotoxy(80,i);printf("*");
}
gotoxy(31,3);printf("FACTORIALES");
gotoxy(15,7);printf("ingrese el limite: ");scanf("%d",&l);
for (j=1;j<=l;j++)
{
f=f*j;
gotoxy(20,m);printf("El factorial de: %d = %d",j,f);
m=m+1;
}
gotoxy(15,22);printf("presione 1 para continuar o 0 para salir:
");scanf("%d",&op);
}
while (op==1);
getch();
}

67

LECTURA DE

FIN
CORRIDO DEL PROGRAMA

Programa Nº14
 Diseñe un programa que me permita ejercer la tabla de multiplicación de
cualquier factor imprimido desde teclado y por cualquier limite impreso
desde teclado, el programa se genera n veces, diseñe el borde de la
pantalla.
Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la
condición requerida, sentencias for, realizamos los procesos y presentamos
resultados.
DOCUMENTACIÓN
LIBRERIAS

#include<stdio.h>
#include<conio.h>
main ()
{
int fac,lim,i,n,m,j,op ;
do
{
clrscr();
//borde de pantalla
m=9;
for (i=1;i<=80;i++)
{
gotoxy(i,1); printf("*");
gotoxy(i,24);printf("*");
}
for (i=1;i<=24;i++)

VARIABLES
INICIO

SENTENCIA “FOR”

68
{
gotoxy(1,i); printf("*");
gotoxy(80,i);printf("*");
}
//tabla de multiplicar
gotoxy(31,3); printf("TABLAS DE MULTIPLICAR");
gotoxy(10,5); printf("Factor: ");scanf("%d",&fac);
gotoxy(10,7); printf("Limite: ");scanf("%d",&lim);
for(j=1;j<=lim;j++)
{
n=fac*j;
gotoxy(19,m); printf("%d",fac);
gotoxy(21,m); printf("*");
gotoxy(23,m); printf("%d",j);
gotoxy(25,m); printf("=");
gotoxy(27,m); printf("%d",n);
m=m+1;
}
gotoxy(8,22); printf("presione 1 para regresar o 0 para salir:
");scanf("%d",&op);
}
while (op==1);
getch();
}

69

FIN
CORRIDO DEL PROGRAMA

Programa Nº15
 Diseñe un programa en c++ que me permita visualizar los números
primos con repetición y el borde.
Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la
condición requerida, sentencias for, realizamos los procesos y presentamos
resultados.
DOCUMENTACIÓN
LIBRERIAS

#include<conio.h>
#include<stdio.h>
main()
{
int i=0,j=0,lt,c,res=0,op=1,nc=0;
do
{
clrscr();
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(79,i);printf("*");
}
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");

VARIABLES
INICIO

SENTENCIA “FOR”

70
}
gotoxy(29,2);printf("NUMEROS PRIMOS");
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++)
{
if(i%j==0)
{
nc=nc+1;
}
}
if(nc==2)
{
printf("%6d",i);
}
nc=0;
c=c+1;
}
gotoxy(2,23),printf("REPETIR 1 Y 0 PARA SALIR : ");scanf("%d",&op);
}
while(op==1);
getch();
FIN
}

71
CORRIDO DEL PROGRAMA

Programa Nº16
 Diseñe un programa que me permita generar cualquier seria de
números.
Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la
condición requerida, sentencias for, realizamos los proceso y presentamos
resultados.
DOCUMENTACIÓN
LIBRERIAS

#include<conio.h>
#include<stdio.h>
void main()
{
int limite,i,fla,op;
do
{
clrscr();
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)

VARIABLES
INICIO

SENTENCIA “FOR”

72
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
flushall();
gotoxy(25,5);printf("Series");
gotoxy(15,6);printf("Ingrese limite: ");scanf("%d",&limite);
fla=6;
for(i=2;i<=limite;i+=2)
{
gotoxy(20,fla+1);printf("%d",i);
fla=fla+1;
}
fla=7;
for(i=1;i<=limite;i+=2)
{
gotoxy(40,fla);printf("%d",i);
fla=fla+1;
}
gotoxy(15,20);printf("Desea salir 1/0: ");scanf("%d",&op);
}while(op==1);
getch();
}

73

SENTENCIA “FOR”

FIN
CORRIDO DEL PROGRAMA

Programa Nº17
 Diseñe un programa que me permita generar una serie de números, en
donde el numerados es cualquier factor ingresado desde teclado, y el
numerador es la serie de los números impares.
Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la
condición requerida, sentencias for, realizamos los procesos y presentamos
resultados.
DOCUMENTACIÓN

LIBRERIAS

#include<stdio.h>
#include<conio.h>
void main ()
{
int i,l,j,c,d,s,p,op,fa;
do
{
clrscr();
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)

VARIABLES
INICIO

SENTENCIA “FOR”

74
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
gotoxy(16,2);printf("SERIE DE NUMEROS NUMERADOR
CUALQUIER,DENOMINADOR IMPAR");
gotoxy(10,3);printf("Ingrse el limite: ");scanf("%d",&l);
gotoxy(10,4);printf("ingrese el factor:");scanf("%d",&fa);
c=0;
d=1;
for(i=1;i<=l;i++)
{
c=c+3;
gotoxy(5,6+i);printf("%d",c);
d=d+2;
gotoxy(13,6+i);printf("%d",d);
gotoxy(9,6+i);printf("/");
}
gotoxy(10,20);printf("Desea continuar 1 caso contario 0:
");scanf("%d",&op);
}while(op==1);
getch();
}

75

LECTURA DE

FIN
CORRIDO DEL PROGRAMA

Programa Nº18
 Realice un programa que me permita general la siguiente serie de datos:
N= 5
Factor impar como numerador
Factorial como denominador
Análisis.- Utilizamos variables de tipo enteras y decimales, do-while para
que cumpla la condición requerida, sentencias for, realizamos los procesos
y presentamos resultados.
DOCUMENTACIÓN

LIBRERIAS

#include<conio.h>
#include<stdio.h>
void main()
{
int s,f,i,d,j,op;
float factorial;
do
{
clrscr();
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");

VARIABLES
INICIO

SENTENCIA “FOR”

76
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
gotoxy(15,2);printf("SERIE DE NUMEROS CON NUMERADOR
IMPAR E FACTORIAL DENOMINADOR");
gotoxy(10,3);printf("Ingrse el limite: ");scanf("%d",&s);
do
{
gotoxy(32,4);printf(" ");
gotoxy(10,4);printf("ingrese el factor:");scanf("%d",&f);
} while(f%2==0);
factorial=1;
for(i=1;i<=s;i++)
{
factorial=factorial*i;
gotoxy(5,6+i);printf("%d",f);
f=f+2;
gotoxy(13,6+i);printf("%4.0f",factorial);
gotoxy(9,6+i);printf("/");
}
gotoxy(10,20);printf("Desea continuar 1 caso contario 0:
");scanf("%d",&op);
}while(op==1);
getch();
}

77

IMPRESION

FIN
CORRIDO DEL PROGRAMA

Programa Nº19ç
 Generar n elementos de la siguiente serie, cualquier factor ingresando
desde teclado como numerador, el denominador números pares.
Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la
condición requerida, sentencias for, realizamos los procesos y presentamos
resultados.
DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
void main ()
{
int i,l,j,c,d,s,p,op,fa;
do
{
clrscr();
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");

LIBRERIAS
VARIABLES
INICIO

SENTENCIA “FOR”

78
}
gotoxy(16,2);printf("SERIE DE NUMEROS NUMERADOR
CUALQUIER,DENOMINADOR PAR");
gotoxy(10,3);printf("Ingrse el limite: ");scanf("%d",&l);
gotoxy(10,4);printf("ingrese el factor:");scanf("%d",&fa);
c=0;
d=0;
for(i=1;i<=l;i++)
{
c=c+3;
gotoxy(5,6+i);printf("%d",c);
d=d+2;
gotoxy(13,6+i);printf("%d",d);
gotoxy(9,6+i);printf("/");
}
gotoxy(10,20);printf("Desea continuar 1 caso contario 0:
");scanf("%d",&op);
}while(op==1);
getch();
}

79

IMPRESION

FIN
CORRIDO DEL PROGRAMA

Programa Nº20
 Genere una serie de datos que lleve por numerador el factorial y por
denominador la serie de Fibonacci
Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la
condición requerida, sentencias for, realizamos los procesos y presentamos
resultados.
DOCUMENTACIÓN

LIBRERIAS

#include<conio.h>
#include<stdio.h>
main()
{
int i, limit, fibon=0, colum=5, b=1, c=0, fac=1, op;
do
{
fibon=0, colum=5, b=1, c=0, fac=1;
clrscr();
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
80

VARIABLES
INICIO

SENTENCIA “FOR”
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
gotoxy(17,3);printf("SERIE NUMERADOR FACTORIAL
Y DENOMINADOR FIBONACCI");
gotoxy(4,5);printf("numero a visualizar: ");scanf("%d",&limit);
LECTURA DE
for(i=1;i<=limit;i++)
{
gotoxy(colum,9);printf("%d",fibon);
fibon=b+c;
b=c;
OPERACIONES
c=fibon;
gotoxy(colum,8);printf("-");
gotoxy(colum,7);printf("%d",fac);
fac=fac*i;
colum=colum+5;
}
gotoxy(3,22);printf("PRESIONE 1 PARA REPETIR LA SERIE O 0 PARA LECTURA DE
FINALIZAR>> ");scanf("%d",&op);
}
while(op==1);
getch();
}
FIN

81
CORRIDO DEL PROGRAMA

Programa Nº21
 Genere la siguiente serie de datos primos en el numerador e impares en
el denominador.
Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la
condición requerida, sentencias for, sentencias if realizamos los procesos y
presentamos resultados.
DOCUMENTACIÓN

LIBRERIAS

#include<stdio.h>
#include<conio.h>
#include<string.h>
main()
{
int i, j, np, cot=0, c=5, resul, op, colum=15, imp=1, aux;
do
{
imp=1;
colum=15;
c=10;
clrscr();

VARIABLES

82

INICIO
gotoxy(16,3);printf("SERIE NUMERADOR PRIMOS DENOMINADOR
IMPARES");
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
SENTENCIA “FOR”
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
gotoxy(3,5);printf("Limite: ");scanf("%d",&np);
gotoxy(10,7);printf("1");
gotoxy(8,6);printf("Serie: ");
aux=0;
for(i=1;i<=(2*np);i++)
{
if(aux==np)
{break;
}
SENTENCIA “FOR”
cot=0;
for(j=1;j<=i;j++)
{
resul=i%j;
if(resul==0)
{
cot=cot+1;
}
}
if(cot==2)
{
gotoxy(colum,7);printf("%d",i);
aux=aux+1;
gotoxy(colum,8);printf("-");
IMPRESION
colum=colum+5;
gotoxy(c,9);printf("%d",imp);
imp=imp+2;
c=c+5;
}
}
gotoxy(3,23);printf("PRESIONE 1 PARA REPETIR EL PROCESO O 0 PARA
FINALIZAR: ");scanf("%d",&op);
}
while(op==1);
getch();
FIN
}

83
CORRIDO DEL PROGRAMA

84
Programa Nº22
 Realice un menú que me permita realizar las conversiones básicas de
metro, kilometro, hectómetro y decímetro.
Análisis.- Activamos las librerías, utilizamos variables de tipo enteras, y
decimales, do-while para que cumpla la condición requerida, sentencias for,
un swich para las opciones, realizamos los procesos y presentamos
resultados.
DOCUMENTACIÓN
LIBRERIAS

#include<conio.h>
#include<stdio.h>
VARIABLES
#include<stdlib.h>
INICIO
void borde()
{
int i;
clrscr();
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("±");
gotoxy(i,24);printf("±");
SENTENCIA “FOR”
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("±");
gotoxy(80,i);printf("±");
}
}
void main()
{
int op,col=8;
float km,nu,dam,hm,m;
clrscr();
do
{
borde();
gotoxy(32,3);printf("CONVERSIONES BASICAS");
gotoxy(32,2);printf("////////////////////");
IMPRESION
gotoxy(32,4);printf("////////////////////");
gotoxy(5,6);printf("1.- De Metros a Km - Hm - Dam");
gotoxy(5,8);printf("2.- De Kilometros a M - Hm - Dam");
gotoxy(5,10);printf("3.- De Hectometros a M - Km - Dam");
gotoxy(5,12);printf("4.- De Decametros a M - Km - Hm");
gotoxy(5,14);printf("5.- Salir");
gotoxy(5,22);printf("Que opcion desea realizar: ");scanf("%d",&op);
switch(op)
{
case 1:
clrscr();
85
borde();
gotoxy(33,3);printf("De Metros a Km - Hm - Dam");
gotoxy(5,5);printf("Ingrece la cantidad: ");scanf("%f",&nu);
km=nu*0.001;
hm=nu*0.01;
dam=nu*0.1;
gotoxy(col,8);printf("Km = %f",km);
gotoxy(col,10);printf("Hm = %f",hm);
gotoxy(col,12);printf("Dam = %f",dam);
break;
case 2:
clrscr();
borde();
gotoxy(33,3);printf("De Kilometros a M - Hm - Dam");
gotoxy(5,5);printf("Ingrece la cantidad: ");scanf("%f",&nu);
m=nu*1000;
hm=nu*100;
dam=nu*10;
gotoxy(col,8);printf("M = %f",m);
gotoxy(col,12);printf("Hm = %f",hm);
gotoxy(col,10);printf("Dam = %f",dam);
break;
case 3:
clrscr();
borde();
gotoxy(33,3);printf("De Hectometros a M - Km - Dam");
gotoxy(5,5);printf("Ingrece la cantidad: ");scanf("%f",&nu);
km=nu*0.1;
m=nu*100;
dam=nu*10;
gotoxy(col,12);printf("Km = %f",km);
gotoxy(col,8);printf("M = %f",m);
gotoxy(col,10);printf("Dam = %f",dam);
break;
case 4:
clrscr();
borde();
gotoxy(33,3);printf("De Metros a M - Km - Hm");
gotoxy(5,5);printf("Ingrece la cantidad: ");scanf("%f",&nu);
km=nu*0.001;
hm=nu*0.01;
m=nu*10;
gotoxy(col,12);printf("Km = %f",km);
gotoxy(col,10);printf("Hm = %f",hm);
gotoxy(col,8);printf("M = %f",m);
break;
case 5:
exit(0);
break;
}
86

IMPRESION

IMPRESION

IMPRESION

FIN
gotoxy(3,23);printf("1 PARA VOLVER AL MENU DE DATOS 0 PARA
FINALIZAR: ");scanf("%d",&op);
}
while(op==1);
getch();
}

87

FIN
CORRIDO DEL PROGRAMA

Programa Nº23
 Diseñe un programa que me permita realizar un borde utilizaciones
funciones.
Análisis.- Utilizamos una variable de tipo enteras, sentencias for para que
cumpla la condición requerida, llamamos a la función borde y presentamos
resultados.

88
DOCUMENTACIÓN
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int i;
void borde()
{
for(i=1;i<=80;i++)
{
gotoxy(i,24);printf("*");
gotoxy(i,1);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}
void main ()
{
clrscr();
borde();
getch();
}

LIBRERIAS
VARIABLES

INICIO

SENTENCIA “FOR”

FIN

89
CORRIDO DEL PROGRAMA

Programa Nº24
Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la
condición requerida, sentencias for, realizamos los procesos y presentamos
resultados.
DOCUMENTACIÓN
LIBRERIAS

#include<stdio.h>
#include<conio.h>
int numero,i,op;
void borde()
{
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("• ");
gotoxy(i,24);printf("• ");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("• ");
gotoxy(80,i);printf("• ");
}
}
void numeros(int num)
{
for(i=1;i<=numero;i++)

VARIABLES
INICIO

SENTENCIA “FOR”

90
{
gotoxy(15,4+i);printf("%d",i);
}
}
void main()
{
do
{
clrscr();
borde();
gotoxy(15,4);printf("Numero: ");scanf("%d",&numero);
numeros(numero);
gotoxy(15,22);printf("Desea salir 1/0: ");scanf("%d",&op);
}while(op==1);
getch();
}

91

FIN
CORRIDO DEL PROGRAMA

Programa Nº25
 Diseñe un programa que me permita ingresar tres valores enteros
desde teclado entre 4 y 64 y presentarlos en forma ordenada
ascendentemente.
Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la
condición requerida, sentencias for, realizamos los procesos y presentamos
resultados.
DOCUMENTACIÓN
LIBRERIAS

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int i,a,b,c;
void borde ()
{

VARIABLES
INICIO

92
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
SENTENCIA “FOR”
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}
void nun ( )
{
if(a>b && a>c)
{
gotoxy(16,14);printf("%d",a);
}
else
{
if(b<a && b>c)
{
gotoxy(16,15);printf("%d",b);
}
else
FUNSION
{
gotoxy(16,16);printf("%d",c);
}
if(c<a && c>b)
{
gotoxy(16,17);printf("%d",c);
}
else
{
gotoxy(16,18);printf("%d",b);
}
}
}
void main()
{
clrscr();
borde ();
gotoxy(30,3);printf("ASCENDENTE");
do
{
gotoxy(37,5);printf(" ");
gotoxy(12,5);printf("Ingrese el primer numero:");scanf("%d",&a);
}while(a<3||a>65);
do
{
gotoxy(37,7);printf(" ");
93
gotoxy(12,7);printf("Ingrese el segundo numero:");scanf("%d",&b);
}while(b<3||b>65);
do
{
gotoxy(37,9);printf(" ");
gotoxy(12,9);printf("Ingrese el tercer numero:");scanf("%d",&c);
}while(c<3||c>65);
nun ();
getch();
FIN
}

94
CORRIDO DEL PROGRAMA

95
33.-Diseñe un programa utilizando funciones que me permita ingresar 3 valores
enteros desde teclado entre 4 y 64 y presentarlos en forma ordenada
ascendentemente.

ANALISIS
Para este programa se necesitan varias funciones de condición if para hacer la
comparación y así poder imprimir los números en forma ascendente y para
validar los números también otros if para que el número ingresado este el
rango que se pedía en el programa

DOCUMENTACION
#include<stdio.h> LIBRERIAS
#include<conio.h>
int i,a,b,c,op;

Declaración de variables

Inicio de la función borde
void borde()
{
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("±");
gotoxy(i,24);printf("±");
}
Impresión del margen
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("±");
gotoxy(80,i);printf("±");
}
}
void numero()
Inicio de la función void main
{
do
Inicio del do
{
gotoxy(24,4);printf("
");
Ingreso el primer numero
gotoxy(15,4);printf("Numero 1; ");scanf("%d",&a);
}
while(a>64 || a<4);
Si ese número cumple con la condición
empleada pide el siguiente número

do
{
gotoxy(24,5);printf("

Inicio del do

");

Ingreso el segundo numero
96
gotoxy(15,5);printf("Numero 2: ");scanf("%d",&b);
}
Si ese número cumple con la condición
while(b>64 || b<4);
empleada pide el siguiente numero

do
Inicio del do
{
gotoxy(24,6);printf("
");
gotoxy(15,6);printf("Numero 3: ");scanf("%d",&c);
Ingreso el tercer numero
}while(c>64 || c<4);
}
void orden()
Inicio de la función void orden
{
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
if(b<=a && b<=c)
los números 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);
}
97
}
gotoxy(15,7);printf("El orden es:");
}
Inicio de la función principal
void main()
{
do
{
Borrar pantalla
clrscr();
borde();
Llamar al borde
Llamar a la función
numero
Llamar a la función orden

numero();
orden();

gotoxy(15,22);printf("Desea salir 1/0: ");scanf("%d",&op);
}
while(op==1);
Si la opción ingresada por el usuario es igual a 1 el
proceso se repetirá

getch();
}

Fin del programa

CORRIDO DEL PROGRAMA

98
34.- Diseñe un programa utilizando funciones que me permita generar y
visualizar los números perfectos.

ANALISIS




En este programa utilizamos la librería math porque utilizamos la función
pow
Utilizamos un do –while para que el usuario ingrese otro limite o quiera
salir del programa
Aquí también empleamos la utilización de las funciones

DOCUMENTACION
#include<stdio.h>
LIBRERIAS
#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++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}
void perfecto(int l)
{
r=pow(dos,ex);
s=pow(dos,ex2);
v=r*(s-1);
gotoxy(7,8);printf("%d",v);
for(i=1;i<=l-1;i++)
{
a=pow(dos,expo2);

Inicio de la función borde

Impresión del margen

Inicio de la función void
perfecto
Operaciones para sacar los
números perfectos

Operaciones para sacar los
números perfectos
99

Declaración de variables
b=pow(dos,expo3);
expo2=expo2+2;
expo3=expo3+2;
c=a*(b-1);
gotoxy(7,f);printf("%d",c);
f=f+1;
}
}//cierre del void

Impresión de los números
perfectos

Inicio de la función principal
void main()
{
do
{
f=9,dos=2,ex=1,ex2=2,expo2=2,expo3=3,f=9; Declaración de variables

clrscr();

Borrar pantalla
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 función perfecto

Impresión del titulo

Ingreso del limite

perfecto(l1);
gotoxy(50,22);printf("
");
gotoxy(4,22);printf("PRESIONE 1 PARA VOLVER AL MENU O 0 PARA
SALIR: ");scanf("%d",&op);
}
while(op==1);
Si la opción ingresada por el usuario es igual a 1 el
proceso se repetirá

getch();
}

Fin del programa

CORRIDO DEL PROGRAMA

100
35.- Diseñe un programa utilizando funciones que me permita resolver un
sistema de ecuación de 2° grado.
ANÁLISIS
Partiremos escribiendo la fórmula para tener base de que nomás se va a
utilizar.

La fórmula genera dos respuestas: Una con el signo más (+) y otra con el signo
menos (−) antes de la raíz. Solucionar una ecuación de segundo grado se
limita, entonces, a identificar las letras a, b y c y sustituir sus valores en la
fórmula.
La fórmula general para resolver una ecuación de segundo grado sirve para
resolver cualquier ecuación de segundo grado, sea completa o incompleta, y
obtener buenos resultados tiene que ver con las técnicas de factorización.

CODIFICACIÓN
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <math.h>
int i,j,op;
void borde()
{
textcolor(BLUE);
for(i=1;i<=80;i++)
{
gotoxy(i,1);cprintf("*");
gotoxy(i,24);cprintf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);cprintf("*");
gotoxy(80,i);cprintf("*");
}
}
void seg ()
{
float a, b, c;
float x1, x2;
float x1real, x2real;

Activation de Liberia

// declaración de variables globales

función del borde

// impression de *
// fin del ciclo for
// fin de la function borde
// function para la ecuacion
// inicio de la function

/* complejas
101

*/
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
GRADOn");
gotoxy(2,4);printf("==============================================
================n");
gotoxy(10,5);printf("El programa soluciona la ecuación de segundo gradon");
gotoxy(10,6);printf("
2
n");
gotoxy(10,7);printf("ax + bx + c = 0
n");
/* Petición 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);
/* Cálculos y resultados */
discriminante = b*b - 4*a*c;
// calculo de discriminate
printf("n La ecuacionn");
printf(" %14dn", 2);
printf(" %12gx + %gx + %g = 0n", a, b, c); // impresiones
printf(" tiene por soluciones ");
if (discriminante == 0)
// sentencia si dis es = a 0
{
// inicio de if
printf(" una raiz real doblen"); // impresión
x1 = x2 = -b / (2*a);
// calculo
printf(" x1 = %.2fn", x1);
printf(" x2 = %.2fn", x2);
// impresión en pantalla
}
// fin de if
else if (discriminante > 0)
//si dis es mayor a cero
{
// cálculos
printf(" dos raices realesn");
x1 = (-b + sqrt(discriminante)) / (2*a);
x2 = (-b - sqrt(discriminante)) / (2*a);
// impresiones
printf("x1 = %.2fn", x1);
printf("x2 = %.2fn", x2);
}
Else
// caso contrario
{
//impresión en pantalla
printf("dos raíces complejas conjugadasn");
//cálculos
x1real = x2real = -b / (2*a);
x1imag = sqrt(-discriminante) / (2*a);
x2imag = -sqrt(-discriminante) / (2*a);
// impresiones
102
}
}
void main ()
{
Do
{

printf("x1 = ( %.2f, %.2fi)n", x1real, x1imag);
printf("x2 = ( %.2f, %.2fi)n", x2real, x2imag);
//fin del ese
// fin de la función
// inicio del programa
// llave de inicio
//ciclo do
// llave de inicio de do

borde ();
// funcion borde
seg ();
// funcion seg
gotoxy(22,22);printf("desea continuar: ");scanf("%d",&op); // impresión en
pantalla y lectura
} while(op==1);
getch(); //pausa
} // fin del programa.
Corrido del Programa

103
38.- Diseñe un programa utilizando vectores y funciones que me permita
ingresar datos a un vector y presentarlos en otro vector
ANÁLISIS
Primero ingresamos las librerías que vamos a utilizar en este programa en este
caso son las dos principales la STDIO.H Y LA CONIO.H, después como es un
programa con funciones declaramos la variable que vamos a utilizar
globalmente.
Después ingresamos una función 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 demás variables a
realizar en el programa (int vector1[10],fila,op,lim;), después ponemos un
do-while para que se repita el programa n veces y llamamos las funciones
realizadas y realizamos el ingreso del límite para que podaos ingresar datos a
una función y que luego se visualice.
DOCUMENTACIÓN
#include<stdio.h>

Librerías que vamos a utilizar en el programa

#include<conio.h>
int i;

Declaramos la variable global

void borde()
{
for(i=1;i<=80;i++)
{
gotoxy(i,1); printf("*");
gotoxy(i,24); printf("*");
}

Realizamos la función para que se pueda
realizar un borde en nuestro programa

for(i=1;i<=24;i++)
{
gotoxy(1,i); printf("*");
gotoxy(80,i); printf("*");
}
}
void main()
{

Realizamos el programa principal y declaramos la
variables que vamos a utilizar en el programa principal
104
int vector1[10],fila,op,lim;
do
{
clrscr();
borde();
gotoxy(25,3); printf("**VISUALIZAR DATOS VECTOR**");

Aquí damos un limite al vector
para poder dar datos
numéricos a un limita vector

gotoxy(10,5); printf("INGRESE EL LIMITE==>");
scanf("%d",&lim);

Ingresamos el limite

fila=6;
for(i=1;i<=lim;i++)
{
do
{
gotoxy(20,fila); printf(" ");
Ingresamos los números para que se llene
el vector previamente dado un limite

gotoxy(20,fila); scanf("%d",&vector1[i]);
}
while(vector1[i]<3 || vector1[i]>23);

Damos o validamos los datos que estén entre 3 y 23

fila=fila+1;
}
fila=6;
for(i=1;i<=lim;i++)
Aquí se visualiza el vector que
ingresamos en otra posición

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

}
gotoxy(10,20); printf("PRESIONE 1 PARA REPETIR EL PROGRAMA CASO
CONTRARIO 0==>");
scanf("%d",&op);

Ingresamos otra opción para ver si se repite el programa n veces

}
while(op);
getch();

Visualiza la opción y da por terminado el
programa

}
105
106
CORRIDO DEL PROGRAMA

107
41.- Diseñe un programa utilizando vectores y un menú de opciones que me
permita realizar las 4 operaciones básicas, estas son: suma, resta,
multiplicación y división.
ANALISIS
En este programa se realizan las operaciones básicas que son la suma, resta,
multiplicación y división 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 división en
donde el valor del vector1 debe ser mayor al valor del vector2 si no se cumple
la condición no se realiza las operaciones y se imprime un mensaje.
DOCUMENTACION
#include<stdio.h>
#include<conio.h>

Ingreso las
librerías

#include<stdlib.h>

int multivec[15],opc,divisionvec[15],
restavec[15],i,op,col,fila,vector1[15],vector2[15],

Declaración de
variables

sumavec[15],limite1;

void borde()

Función borde

{
for(i=1;i<=80;i++)
{
Este proceso
es para realizar
el borde

gotoxy(i,1); printf("*");
gotoxy(i,24); printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i); printf("*");
gotoxy(80,i); printf("*");
}
}
void ingreso(int limite1)

Función para ingresar los valores
de los vectores
108
{
col=12;
fila=8;

Ingresamos la posición en la cual
se va a visualizar los vectores

for(i=1;i<=limite1;i++)
{

Utilizamos el for para poder
ingresar los valores del vector1 y
vector2 al final vamos sumando fila
para q vayan colocándose en las
posiciones correctas, cerramos la
laves del for y la llaves de la
función ingreso.

gotoxy(col,fila); scanf("%d",&vector1[i]);
gotoxy(col+10, fila); scanf("%d",&vector2[i]);
fila=fila+1;
}
}
void suma(int limite1)

Función 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.

for(i=1;i<=limite1;i++)
{
sumavec[i]=vector1[i]+vector2[i];
gotoxy(40,fila); printf("%d",sumavec[i]);
fila=fila+1;
}

Utilizamos el for para poder
ingresar los valores del vector1 y
vector2, realizamos la operación
en donde se suman los dos
vectores
e
imprimimos
el
resultado, vamos sumando fila
para las correctas posiciones
cerramos el for y la función suma.

}
void resta(int limite1)
{

fila=8;

Función para realizar la resta

Abrimos con una llave
Ingresamos el valor de la fila en la que va a
empezar a visualizarse los datos del vector.

109
for(i=1;i<=limite1;i++)
{
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;
}
}

Utilizamos el for para poder
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
condición
se
cumple
realizamos la operación en
donde se resta los valores
del vector que sea mayor e
imprimimos el resultado,
cerramos el if y si no se
cumple
la
condición
escribimos un mensaje y no
se realiza la operación,
cerramos la llaves y vamos
sumando fila para las
correctas
posiciones
cerramos el for y la función

void multi(int limite1)

Función para realizar la multiplicación

{

Abrimos con una llave

fila=8;

Ingresamos el valor de la fila en la que va a
empezar a visualizarse los datos del vector.

for(i=1;i<=limite1;i++)

Utilizamos el for para poder
ingresar los valores del vector1 y
vector2, realizamos la operación
en donde se mulitiplican los dos
vectores
e
imprimimos
el
resultado, vamos sumando fila
para las correctas posiciones
cerramos el for y la función multi.

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

Función para realizar la división.

{

Abrimos con una llave

fila=8;

Ingresamos el valor de la fila en la que va a
empezar a visualizarse los datos del vector.
110
for(i=1;i<=limite1;i++)
{
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;
}
}
void main()
{

Utilizamos el for para poder
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
condición
se
cumple
realizamos la operación en
donde se dividen los valores
del vector que sea mayor e
imprimimos el resultado,
cerramos el if y si no se
cumple
la
condición
escribimos un mensaje y no
se realiza la operación,
cerramos la llaves y vamos
sumando fila para las
correctas
posiciones
cerramos el for y la función
división.

Función principal del programa.
Abrimos con una llave

do
{

clrscr();

Utilizamos el ciclo do while para que el proceso se
repita tantas veces desee el usuario
Limpia la pantalla.

borde();

Llama a la función borde.
gotoxy(15,3); printf("**OPERACIONES CON VECTORES Y FUNCIONES**");
gotoxy(10,5); printf("1.-SUMA");
Diseño de pantalla.

gotoxy(10,7); printf("2.-RESTA");
gotoxy(10,9); printf("3.-MULTIPLICACION");
gotoxy(10,11); printf("4.-DIVISION");
gotoxy(10,13); printf("QUE OPCION DESEA==>");

111
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(21,7); printf("VECTOR 2");
gotoxy(40,7); printf("SUMA VECTOR");
gotoxy(10,5); printf("INGRESE LIMITE==>");
scanf("%d",&limite1);
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
{

112
clrscr();
borde();
gotoxy(30,3); printf("2.-RESTA");
gotoxy(11,7); printf("VECTOR 1");
gotoxy(21,7); printf("VECTOR 2");
gotoxy(40,7); printf("RESTA VECTOR");
gotoxy(10,5); printf("INGRESE LIMITE==>");
scanf("%d",&limite1);
ingreso(limite1);
resta(limite1);

Diseño de la segunda
opción 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
cerramos con un break.

gotoxy(10,23); printf("SI DESEA REPETIR
EL PROCESO PRESIONE 1 CASO CONTRARIO 0==>");
scanf("%d",&opc);
}
while(opc==1);
break;
case 3:
do
{
clrscr();
borde();
gotoxy(30,3); printf("3.-MULTIPLICACION");
gotoxy(11,7); printf("VECTOR 1");
gotoxy(21,7); printf("VECTOR 2");

Diseño de la tercera
opción 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
cerramos con un break.

gotoxy(40,7); printf("MULTIPLICACION VECTOR");
gotoxy(10,5); printf("INGRESE LIMITE==>");
scanf("%d",&limite1);
ingreso(limite1);
multi(limite1);
gotoxy(10,23); printf("SI DESEA REPETIR EL PROCESO PRESIONE 1 CASO
CONTRARIO 0==>");
113
scanf("%d",&opc);
}
while(opc==1);
break;
do
{
case 4:
clrscr();
borde();
gotoxy(30,3); printf("4.-DIVISION");
gotoxy(11,7); printf("VECTOR 1");
gotoxy(21,7); printf("VECTOR 2");
gotoxy(40,7); printf("DIVISION VECTOR");
gotoxy(10,5); printf("INGRESE LIMITE==>");
scanf("%d",&limite1);
ingreso(limite1);

Diseño de la cuarta
opción 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
cerramos con un break.

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
función 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
114
while(op==1);
getch();
}

Pausa.
Cerramos la función
main.

CORRIDO DEL POGRAMA

115
116
42.- Diseñe un programa utilizando funciones que me permita ingresar n números en un vector
entre 6 y 26, recorra el vector y encuentre todas las posiciones pares y asígnelas a un nuevo
vector, recorra el vector original y encuentre todas las posiciones impares del vector y
asígnelos a un nuevo vector, visualice el vector de entrada y los vectores resultantes.

ANALISIS
Nos pedirá ingresar un límite 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í también nos genera un borde como diseño del programa, y como final tenemos ingresar
uno para continuar utilizando nuestro programa o 0 para salir del mismo.
DOCUMENTACION
#include<conio.h>
#include<stdio.h>

Activación de librería esto habilita
procesos para el programa

#include<stdlib.h>
int i, j=1, f, vect[10], vectpar[10], vectimp[10], op, l;
void bdob()

Declaración de variables
que se utilizaran en el
programa

{
int i;

Función borde

clrscr();
gotoxy(1,1);printf("*");
gotoxy(80,1);printf("*");

Generación del borde
utilizando posiciones e
imprimiendo el borde que
va a ir en pantalla

for(i=2;i<=79;i++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
gotoxy(1,24);printf("*");
gotoxy(80,24);printf("*");
for(i=2;i<=23;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}
117
void par()
{
j=1;
for(i=1;i<=l;i++)
{
if(i%2==0)
{
vectpar[j]=vect[i];
j=j+1;
}

Proceso de comparación si la
posición es par y se
almacenara en un nuevo
vector y se imprimirá en
pantalla utilizaremos el
gotoxy para posiciones en
pantalla

}
f=10;
for(i=1;i<j;i++)
{
gotoxy(39,f);printf("%d",vectpar[i]);
f=f+1;
}
}

void impar()
{

Función para ver si la posición es
impar

j=1;
for(i=1;i<=l;i++)
{

Comparación si la función es impar

if(i%2==1)
{
vectimp[j]=vect[i];

Almacenamiento en un nuevo
vector

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

Impresión de datos de las
posiciones impares

}
}
void main()

Programa principal

{
do
{
flushall();

Do while este nos ayuda a
utilizar el programa cuantas
veces deseemos

f=10;
clrscr();
bdob();

Limpia pantalla
Llama a la función del borde

gotoxy(36,3);printf("VECTORES");
gotoxy(5,5);printf("Ingrese el limite>> ");scanf("%d",&l);

Pide ingresar un limite de
generación de datos

gotoxy(15,8);printf("VECTOR 1");
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);

Ingreso de datos del vector

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

Validación de los datos, estos
deben ser mayor que seis y
menor que veinte y seis

}
par();

Llama a la función par
Llama a la función impar
119
impar();
gotoxy(3,22);printf("PRESIONE
");scanf("%d",&op);

1

PARA

CONTINUAR

O

}
while(op==1);

Cierre del do while

getch();
}

Cierre o fin del programa

CORRIDO DEL PROGRAMA

120

0CASO

CONTRARIO::>
43.-Diseñe 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.
DOCUMENTACION
#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()
{
ELABORACION DE UN BORDE PARA
DISEÑO DE PANTALLA UTILIZANDO
POSICIONES.

for(i=1;i<=79;i++)
{
gotoxy(80,1);printf("*");
gotoxy(1,1);printf("*");
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=2;i<=23;i++)
{
gotoxy(1,24);printf("*");
gotoxy(80,24);printf("*");
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}
void serie(int m)

FUNCION SERIE DONDE GENERARA
EL FIBONACI Y EL FACTOREAL

{
a=1;

IGUALACION DE VARIABLE. DESDE
QUE NUMERO DESEAMOS QUE
EMPIESE

b=0;
121
f=1;
gotoxy(9,6);printf("FIBONACI

FACTOREAL");

for(i=1;i<=m;i++)

IMPRIMIRA LOS MENSAJES QUE
DESEEMOS

{

REALIZARA OPERACIONES PARA
CALCULAR FIBONACI Y FACTOREAL

f=f*i;
c=a+b;
a=b;
b=c;
gotoxy(15,8+i);printf("%d",c);

IMPRIMIRA LOS RESULTADOS DE
FIBONACI Y FACTOREAL

gotoxy(25,8+i);printf("%0.0f",f);

COMPRUEBA SI LA POSICION ES
PAR O IMPAR

if(i%2==0)
{
vect[i]=c;
}
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;
}
}

PROGRAMA PRINCIPAL

void main()
{
do

CICLO DO WHILE ESTE
AYUDARA A REGRESAR AL
PROGRAMA CUANTAS VECES

{
122
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);
CIERRE O FIN DEL
PROGRAMA

getch();
}

CORIDO DEL PROGRAMA

123
44.- Diseñe 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.
ANÁLISIS





Primero ingresamos las librerías las cuales son muy importantes.
Luego realizamos un for donde nos permite hacer el borde de nuestro
programa.
Realizamos una función en la cual hacemos el proceso de los números
pares e impares con vectores.
Para finalizar abrimos la función principal donde llamamos a las demás
funciones para que se realice el proceso y asi finalizamos nuestro
programa, y obtenemos lo que deseamos.

DOCUMNTACION
#include<conio.h>

Librerías 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);
gotoxy(i,1);cprintf("Í");

Nuestro Borde
acompañado de una
Función.

gotoxy(i,24);cprintf("Í");
}
gotoxy(1,24);cprintf("È");gotoxy(80,24);cprintf("¼");
for(i=2;i<=23;i++)
{
124
textcolor(i);
gotoxy(1,i);cprintf("º");gotoxy(80,i);cprintf("º");
}
}
void busq(int l)

Función donde realizaremos el proceso del ejercicio

{

Abrimos llave para nuestra Función.

f=9;

Igualación de variables

for(i=1;i<=l;i++)
Este for nos indica el límite y
abrimos la llave del primer for.

{

if(vect[i]%2==0)

Dentro del for realizamos un if
donde nos indica si la división
es igual a cero es para el
número par, e imprimimos en un
nuevo vector el resultado en
caso que sea número par.

{
gotoxy(34,f);printf("%d",vect[i]);
f=f+1;
}
}

f=9;

Cerramos la llave del primer for

Igualación de la variable

for(i=1;i<=l;i++)
{

Este es un segundo for nos indica el
límite y abrimos llave para inicializar el for.

if(vect[i]%2==1)
{
gotoxy(55,f);printf("%d",vect[i]);
f=f+1;
}

Dentro
del
segundo
for
realizamos un if donde nos
indica si el residuo de la división
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 función.

125
}
}

void main()

Comenzaremos con el programa

{

do
{

Abrimos la sentencia.

clrscr();

Limpiar pantalla.

bdob();

Llamamos a la función borde.

gotoxy(21,3);printf("<<BUSQUEDA
IMPARES_VECTORES>>");

DE

#

PARES

E

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>>");
Impresión de mensajes
f=9;

Posición de fila

for(i=1;i<=lim;i++)

Este for nos indica el límite 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.

gotoxy(18,f);printf(" ");
gotoxy(18,f);scanf("%d",&vect[i]);
}
126

Declaramos la posición de fila.
while(vect[i]<3 || vect[i]>33);
f=f+1;
}

busq(lim);

Llamamos a la función

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.

}

Corrido del Programa

127
45.- Diseñe 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
para las posiciones impares del vector.
Librerías

DOCUMNTACION

#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("-");
gotoxy(80,i);printf("-");
}
for(i=1;i<=80;i++)
{
gotoxy(i,2);printf("-");
gotoxy(i,24);printf("-");
}
}
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();
128

Declaración de variables

Función global para el borde,
e inicio del ciclo, da color

Inicio de la función factor
y del ciclo for

Condición para calcular los
factores impares y pares

Inicio del programa
principal

Inicio de el ciclo do while
llamamos al borde ye
ingresamos el limite
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);
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();
}

CORRIDO DEL PROGRAMA

129

Ingreso de los
números pares

Ingreso de los impares,
repetición del proceso y fin
del programa
46.- Diseñe 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>
Librerías, declaración de
int i,conta,residuo,j,op,fila=5,k,aux,limite,vec[10];
variables he inicio de la
void borde()
función borde
{
for(i=1;i<=79;i++)
{
gotoxy(i,1);printf("-");
gotoxy(i,23);printf("-");
}
Proceso de borde
for(i=1;i<=23;i++)
{
gotoxy(1,i);printf("-");
gotoxy(79,i);printf("-");
}
}
void ingreso()
{
int fila=5;
for(i=1;i<=limite;i++)
{
Inicio de la función para el
do
ingreso con un rango entre
{
6 y 26
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++)
{
Inicio de función
for (j=1;j<=limite;j++)
ascendente calculamos
{
con dos for y una
if (vec[i]<vec[j])
condición Y para la
{
aux=vec[i];
impresión un for mas para
vec[i]=vec[j];
el vector
vec[j]=aux;
}
}
}
for (i=1;i<=limite;i++)
{
gotoxy(40,fila);printf("%d",vec[i]);
130
fila=fila+1;
}
}
void descendente ()
{
Inicio de función
int fila=5;
descendente calculamos
for (i=1;i<=limite;i++)
con dos for
{
for (j=1;j<=limite;j++)
{
if (vec[i]>vec[j])
{
aux=vec[i];
vec[i]=vec[j];
vec[j]=aux;
}
Usamos una
}
condición Y para
}
la impresión un
for (i=1;i<=limite;i++)
for mas para el
{
vector
gotoxy(55,fila);printf("%d",vec[i]);
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();
}

131

Inicio del
programa
principal
llamamos
funciones he
ingresamos el
limite
CORRIDO DEL PROGRAMA

132
47.- Diseñe 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.
ANALISIS

En este programa presentado, vamos a trabajar con funciones y vectores donde
tenemos que la posiciones impares se me ubique el número ingresado y el factorial
tiene que ubicarse en las posiciones pares del vector donde después vamos a ordenar
el vector en orden ascendente y en orden descendente en el cual también
utilizaremos una variable “op” que se utilizara para la opción desea continuar SI o NO,
esto se lo realiza con el Laso DO – WHILE que permite generar nuevamente el
programa.

CODIFICACION
Ingreso las
librerías

Declaración de
variables

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

int op,i,j,limite,au,aux,mu,factor,fa,fila,vecto[15];

void borde()
Función borde

{

for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
Este proceso es
para realizar el
borde

gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
133
}
}
Función de la serie

void facto()
{

fila=9;
mu=0;
Igualación de las
variables

au=1;
factor=1;

Que el for vaya
hasta el límite

for(i=1;i<=limite;i++)
{

if(i%2==1)
{
mu=mu+fa;
vecto[i]=mu;
En este proceso es para
que podamos sacar los
números impares donde
el número ingresado lo
dividimos para 2 sino
caso contrario sacamos el
factor y después vamos a
imprimir el vector [i]
donde después vamos a
ir sumando la fila más 1
para la posición del

}
else
{
factor=factor*au;
au=au+1;
vecto[i]=factor;
}
gotoxy(7,fila);printf("%d",vecto[i]);

134
fila=fila+1;
}
}

Ingresamos una
nueva función que se
llama orden

void orden()
{

for(i=1;i<=limite;i++)
{
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 externo
donde el vector [i]sea
menor que el vector[j]
después vamos a
mandar otro for que
vaya hasta el límite y
posteriormente
vamos a imprimir el
vector [i]

aux=vecto[i];
vecto[i]=vecto[j];
vecto[j]=aux;
}
}
}
fila=9;
for(i=1;i<=limite;i++)
{
gotoxy(20,fila);printf("%d",vecto[i]);
fila=fila+1;
}
fila=9;
for(i=1;i<=limite;i++)

135
Posición en donde
que quiero que se
me imprima printf

{
for(j=1;j<=limite;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 externo
donde el vector [i]sea
mayor que el vector[j]

{
if(vecto[i]>vecto[j])
{
aux=vecto[i];
vecto[i]=vecto[j];
vecto[j]=aux;
}
}
}
fila=9;

Después vamos a
mandar otro for que
vaya hasta el límite y
después vamos a
imprimir el vector [i]

for(i=1;i<=limite;i++)
{
gotoxy(35,fila);printf("%d",vecto[i]);
fila=fila+1;
}
}

void main()
Abro el programa

{
do
Abro el do

{
Limpio de pantalla

clrscr();

Llama a la función
de borde

borde();

Posición en donde
que quiero que se
me imprima printf

gotoxy(25,3);printf("FacPares/Impares");

136
Pide el límite que
quieres imprimir
gotoxy(12,5);printf("Ingrese el limite:
");scanf("%d",&limite);

Pide el factor que
quieres imprimir

gotoxy(10,7);printf("Factor: ");scanf("%d",&fa);

Llamo a la función
facto

facto();

Llamo a la función
orden

orden();

Se me imprime
mensaje para
continuar o terminar
el programa
Cierro la función de
do-while
Cierro el programa

gotoxy(5,20);printf("Presione 1 para repetir el proceso o
0 para salir: ");scanf("%d",&op);

}
while(op==1);
getch();
}

137
CORRIDO DEL PROGRAMA

138
48.-Diseñe un programa con funciones y vectores que me permita
ingresar un sin número de elementos en un vector entre 3 y 25, recorrer el
vector y encontré todos aquellos valores que sean números primos
asígnelos en un nuevo vector y preséntelos ordenados en forma
ascendente y descendente.

ANÁLISIS
Para realizar este programa necesitamos utilizar funciones tanto para el borde
como para los números primos y para ordenar dichos números 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 función a la cual denominaremos pri ya que también dentro de esta
función realizaremos las operaciones para encontrar los números primos
para lo cual necesitamos de la condición if y de ciclos for los cuales nos
ayudaran a generar dichos números.
 Par ordenar el vector de forma ascendente y descendente necesitamos
de una función denominada as para la forma ascendente y de una
función 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.
 Además utilizamos un ciclo do while para repetir este proceso el número
de veces que el usuario desee.
.

DOCUMENTACIÓN
#include<conio.h>

Ingresamos las librerías que vamos a utilizar

#include<stdio.h>
int f1, aux, num, i, j, f, vect[100];

Ingresamos las variables que vamos a utilizar, son variable
de tipo enteras

int vectser[100], lim, op, cont;

void borde()

139
{
int i;
clrscr();
gotoxy(1,1);printf("É");
gotoxy(80,1);printf("»");
for(i=2;i<=79;i++)
Aquí realizamos una función para
poder realizar el borde en el programa

{
gotoxy(i,1);printf("Í");
gotoxy(i,24);printf("Í");
}
gotoxy(1,24);printf("È");
gotoxy(80,24);printf("¼");
for(i=2;i<=23;i++)
{
gotoxy(1,i);printf("º");
gotoxy(80,i);printf("º");
}}
void primo(int l)
{

Aquí realizamos una función para
poder verificar si un número es o no

f=9;
f1=9;
for(j=1;j<=l;j++)
{
do
{
Aquí imprimimos y validamos el vector ingresado que este
entre parámetro que nos dieron para realizarlo

gotoxy(18,f);printf(" ");
gotoxy(18,f);scanf("%d",&vect[j]);
140
}
while(vect[j]<3 || vect[j]>25);
f=f+1;

Sumamos a la fila (f=f+1), y igualamos a cero el

cont=0;
for(i=1;i<=vect[j];i++)
{

Este for es para que se imprima en las filas pares

if(vect[j]%i==0)
{
cont=cont+1;
}}
if(cont==2)
Este if es para que se imprima en las filas impares

{
vectser[j]=vect[j];
gotoxy(34,f1);printf("%d",vectser[j]);
f1=f1+1;
}}}
void orden(int l)

Esta función 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 límite y se pregunte a las dos
posiciones, y después de le pregunta con un if si el vector [i] es < que el vector

for(j=1;j<=l;j++)
{
if(vectser[i]<vectser[j])
{
aux=vectser[i];
vectser[i]=vectser[j];

Aquí utilizamos una variable auxiliar
para que tome el valor de otra variable

vectser[j]=aux;
141
}}}
gotoxy(29,9);printf("ASCE");
f=11;

Igualamos la fila a
11

for(i=1;i<=l;i++)
{
gotoxy(39,f);printf("%d",vectser[i]);

Imprimimos al vector de manera ascendente

f=f+1;
}
for(i=1;i<=l;i++)
Estos for son para que se
imprima hasta un cierto límite.

{
for(j=1;j<=l;j++)
{
if(vectser[i]>vectser[j])
{
aux=vectser[i];

Aquí utilizamos una variable auxiliar
para que tome el valor de otra variable

vectser[i]=vectser[j];
vectser[j]=aux;
}}}
gotoxy(52,9);printf("DESC");

Imprimimos al vector de manera descendente

f=11;
for(i=1;i<=l;i++)
{
gotoxy(62,f);printf("%d",vectser[i]);
f=f+1;
}}
void main()

Realizamos el programa principal

{
142
do

Ponemos una sentencia do-while para que se pueda repetir n veces.

{
clrscr();
borde();
gotoxy(21,3);printf("BUSQUEDA DE NUMRS- PARES E IMPARES");
gotoxy(5,5);printf("limite: ");scanf("%d",&lim);

Ingresamos el
límite e
imprimimos un
título

gotoxy(13,7);printf("VECTOR");
gotoxy(26,7);printf("#PRIMOS");
gotoxy(47,7);printf("#IMPARES");
primo(lim);
Llamamos a las demás funciones que ya realizamos.

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

}

143

Cerramos el lazo do-while
CORRIDO DEL PROGRAMA

144
49.- Diseñe 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.

ANÁLISIS
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 posición e imprimirla
necesitamos de una función 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 añadirle color.
 Para encontrar los datos de la cadena de caracteres del vector
necesitamos de una nueva función a la cual la denominaremos void
cont para realizar dicho proceso requerimos de un ciclo for el cual nos
permitirá contar los caracteres ingresados además requerimos de otro
ciclo for el mismo que nos ayudara a imprimir dichos datos.
 Además utilizamos un ciclo do while para repetir este proceso el número
de veces que el usuario desee.

DOCUMENTACIÓN

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

Librerías

#include<string.h>
#include<ctype.h>
char cadena[20],vecimpar[20];
int i,fi,op,n,h;
void borde()

Declaracion de variables tipo caracter
Declaracion de variables enteras

Inicio función borde

{

145
Inicio ciclo for

for (i=1;i<=80;i++)
{

color

textcolor(i+1);
gotoxy(i,1);cprintf("*");

Impresión borde

gotoxy(i,24);cprintf("*");

Fin ciclo for

}
for (i=1;i<=24;i++)

Inicio ciclo for

{

color

textcolor(i+1);
gotoxy(1,i);cprintf("*");

Impresión borde

gotoxy(80,i);cprintf("*");
}

Fin ciclo for

}

Fin función borde

void cad()

Inicio función cad

{
Palabra reservada que permite funcionar ciclo do while

flushall();
gotoxy(30,5);gets(cadena);

Impresión cadena

l=strlen(cadena);

Igualación limite palabra reservada strlen
Igualación fila a 9

fila=9;
for(i=0;i<l;i++)

Inicio ciclo for

{
textcolor(i+1);

color

gotoxy(23,fi);cprintf("%c",cadena[i]);
fila=fila+1;
}

Contador mas 1
Fin ciclo for
Fin función cadena
146

Impresión vector ingresante
}
void cont()

Inicio función cont

{
h=1;

Igualación variable a 1

for(i=0;i<n;i++)

Inicio ciclo for

{
Igualación vector auxiliar a vector ingresante

vecimpar[h]=cadena[i];
h=h+1;

Contador mas 1

}

Fin ciclo for

fila=8;

Igualación variable fila a 8

for(i=0;i<h;i++)

Inicio ciclo for

{
gotoxy(45,fi);printf("%c",vecimpar[i]);
fila=fila+1;
}

Impresión vector resultante

Contador mas 1
Fin ciclo for

}

Fin funcion cad

void main()

Inicio función principal

{
do

Inicio ciclo do while

{
clrscr();
borde();

Blanqueo de pantalla
Se llama a la funcion borde

gotoxy(25,3);printf("<< CARACTERES >>");
gotoxy(8,5);printf("*.CARACTERES : ");

Impresión titulos

gotoxy(15,7);printf("<< V REALIZADO>>");
147
gotoxy(38,7);printf("<< V.RESULTANTE>>");
cad();

Se llama a la funcion cad

cont();

Se llama a la función cont

gotoxy(12,22);printf("PULSE 1 PARA CONTINUAR O 0 PARA SALIR :
");scanf("%d",&op);
}
while(op==1);

Fin ciclo do while

getch();
}

Fin programa

CORRIDO DEL PROGRAMA

148

Impresión
repetición
50.- Diseñe 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.

ANALISIS:












Primero empezamos abriendo nuestras bibliotecas
Después validamos nuestras variables globales, que servirán para la
ejecución de nuestro programa, teniendo en cuenta que estamos
ocupando char que servirá para hacer cadena de caracteres.
Realizamos nuestra primera función llamada borde que nos servirá
para más después abrir en nuestras funciones realizadas
Comenzamos a realizar nuestra primera función 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, además ingresaremos el carácter y un proceso de for en el
cual se almacenen un vector con sus respectivos caracteres.
Después de esto comenzaremos otra función 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.

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

Abrimos las librerías

Iniciamos los valores de nuestro programa

gotoxy(i,1);cprintf("*");
gotoxy(i,24);cprintf("*");
}
for(i=2;i<=23;i++)
{
textcolor(17);

Nuestro borde

149
gotoxy(1,i);cprintf("*");
gotoxy(80,i);cprintf("*");
}
}
Función que ocuparemos

void nomb()
después
{
flushall();
Permite leer el carácter
gotoxy(12,5);gets(nombre);
n=strlen(nombre);
Permite almacenar en otro vector
fi=5;
for(i=0;i<n;i++)
{
if(islower (nombre[i]))
{
For para ingresar el vector,
nombre[i]=toupper(nombre[i]);
utilizamos la función textcolor para
textcolor(i+1);
poner color a las letras
gotoxy(40,fi);cprintf("%c",nombre[i]);
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
{
clrscr();
Borrado de pantalla y llamado de la función
borde();
borde
nomb();
Llamamos a las funciones
textcolor(2);
gotoxy(12,18);cprintf("ingrese el caracter ");scanf("%c",&a); Imprimir el título y subtítulos
de nuestro programa
textcolor(3);
for(i=0;i<n;i++)
{
if(nombre[i]==a)
For para su limite y el if para buscar
{
su posición 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);
150

Cerramos la sentencia do
while
getch();
}

Pausado en el programa y
cerrado del programa

CORRIDO DEL PROGRAMA:

151
51.- Diseñe 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 posición de impares del vector y asignarlos a un
nuevo vector, presente el nuevo vector ordenado.



ANÁLISIS
Empezamos abriendo las librerías para activar funciones, utilizamos
variables de tipo enteras y alfabéticas tres funciones con sentencia “for”,
una para el borde y las dos restantes para realizar los procesos y al
impresión de las letras qu están 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

Librerías.- colección de clases y
#include<stdio.h>
funciones, escritas en el núcleo del lenguaje.
#include<conio.h>
#include<string.h>
Variables.- son un tipo de dato
#include<ctype.h>
char nombre[20],vecimpar[20]; Alfabéticas
Enteras
int i,fi,op,n,h;
void borde()
{
for(i=1;i<=79;i++)
{
textcolor(9);
Sentencia “for” para
gotoxy(i,1);printf("±");
realizar el borde
gotoxy(i,24);printf("±");
}
for(i=2;i<=23;i++)
{
textcolor(9);
gotoxy(1,i);printf("±");
gotoxy(80,i);printf("±");
}
}
void nomb()
Funciones.- Las funciones son
{
flushall();
bloques de código utilizados
Color para el texto
textcolor(3);
para dividir un programa en
Lectura de
gotoxy(5,5);cprintf("TEXTO:");
partes más pequeñas, cada
textcolor(i+1);
variables
una de las cuáles tendrá una
gotoxy(12,5);gets(nombre);
tarea determinada.
n=strlen(nombre);
Impresión del
vector 152
fi=9;
for(i=0;i<n;i++)
Un vector, también llamado
{
array(arreglo)
textcolor(3);
unidimensional, es una
gotoxy(5,7);cprintf("VECTOR");
estructura de datos que
textcolor(i+1);
permite agrupar elementos
gotoxy(8,fi);cprintf("%c",nombre[i]);
del mismo tipo y
fi=fi+1;
almacenarlos en un solo
}
bloque de memoria juntos,
}
uno después de otro. A este
void impar()
{
grupo de elementos se les
h=1;
identifica por un mismo
for(i=0;i<n;i++)
nombre y la posición en la
{
que se encuentran. La
if(i%2==0)
primera posición del array es
{
la posición 0.
vecimpar[h]=nombre[i];
h=h+1;
}
}
Sentencia “for” para la
fi=8;
impresión de las letras
for(i=0;i<h;i++)
en posiciones impares
{
Color para el texto
textcolor(3);
gotoxy(15,7);cprintf("POSICIONES");
textcolor(i+1);
gotoxy(20,fi);cprintf("%c",vecimpar[i]);
fi=fi+1;
}
}
void main()
Inicio del programa
{
Sentencia do while
do
{
Proceso de repetición
Borrar pantalla
clrscr();
Funcion borde
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);
getch();
Pausa
}
Fin del programa

153


CORRIDO DEL PROGRAMA

154
52.- Diseñe un programa utilizando funciones y vectores que me permita leer una
cadena de caracteres, y presentarlos de forma invertida.



ANÁLISIS
Empezamos abriendo las librerías para activar funciones, utilizamos
variables de tipo enteras y alfabéticas tres funciones con sentencia “for”,
una para el borde y las dos restantes para realizar los procesos y al
impresión de la frase invertida, 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

Librerías.-

colección

de

clases

#include<stdio.h>
funciones, escritas en el núcleo del lenguaje.
#include<conio.h>
#include<string.h>
Variables.- son un tipo de dato
char nombre[20],vecimpar[20];
Alfabéticas
int i,fi,op,n,h,j,aux,col;
Enteras
void borde()
{
for(i=1;i<=80;i++)
{
textcolor(5);
gotoxy(i,1);cprintf("±");
Sentencia “for” para
gotoxy(i,24);cprintf("±");
realizar el borde
}
textcolor(5);
for(i=2;i<=24;i++)
{
gotoxy(1,i);cprintf("±");
gotoxy(80,i);cprintf("±");
}
}
void nomb()
{
Funciones.- Las funciones son
flushall();
Color para el texto
bloques de código utilizados
textcolor(2);
para dividir un programa en
gotoxy(5,5);cprintf("TEXTO");
partes más pequeñas, cada
gotoxy(12,5);gets(nombre);
Lectura de
una de las cuáles tendrá una
variables
tarea determinada.
n=strlen(nombre);
fi=8;

Impresión del
vector
155

y
for(i=0;i<n;i++)
{
textcolor(2);
gotoxy(5,7);cprintf("VECTOR");
textcolor(i+1);
gotoxy(9,fi);cprintf("%c",nombre[i]);
fi=fi+1;
}
fi=7;
Sentencia “for” para la
for(i=n;i>=0;i--)
impresión DE LA FRASE
{
INVERTIDA
textcolor(2);
gotoxy(15,7);cprintf("INVERTIDO");
textcolor(i+1);
gotoxy(20,fi);cprintf("%c",nombre[i]);
fi=fi+1;
}
}
void main()
Inicio del programa
{
Sentencia do while
do
Proceso de repetición
{
Borrar pantalla
clrscr();
Funcion borde
borde();
textcolor(5);
gotoxy(15,3);cprintf("VECTORES");
nomb();
Funciones
textcolor(5);
gotoxy(5,22);cprintf("Desea repetir 1 Salir 0: ");scanf("%d",&op);
}while(op==1);
getch();
Pausa
}
Fin del programa

156


CORRIDO DEL PROGRAMA

157
53.- Diseñe un programa utilizando vectores y funciones que me permita leer una cadena de
caracteres y presentarla de forma invertida.

ANÁLISIS:
En este programa hemos utilizado la variable char para declaración con caracteres la
palabra, un get para ingresar datos con caracteres, un “for” para invertir al vector
ingresado e imprimir el en un nuevo vector todo esto se hace en una función global y
al último se llama en una función principal void main.

CODIFICACIÓN:
#include<stdio.h>
#include<string.h>

Librerías

#include<conio.h>
int i,op,fila,a;

Declaración de variables

char nom[40];
void borde()
{
for(i=1;i<=80;i++)

Función global para el borde, e inicio
del ciclo, da color

{
textcolor(i+1);
gotoxy(i,1);printf("!");

Impresión del borde, cierre del ciclo

gotoxy(i,24);printf("!");
}
for(i=2;i<=24;i++)
{

Función global para el borde, e inicio
del ciclo, da color

textcolor(i+1);

gotoxy(1,i);printf("!");

Impresión del borde

gotoxy(80,i);printf("!");
}

Cierre del ciclo y de la
función

}
void inver()
158

Función global e inicio
{
flushall();
gotoxy(20,6);printf("Ingrese la palabra: ");gets(nom);
a=strlen(nom);

Ingreso de datos con caracteres y
almacenarían en auxiliar

fila=9;
for(i=0;i<a;i++)
Ciclo “FOR” ,color para e vector

{
textcolor(i+1);
gotoxy(30,fila);cprintf("%c",nom[i]);
fila=fila+1;

Impresión del vector en forma
vertical

}
fila=8;
for(i=a;i>=0;i--)

Proceso de la forma
invertida con ciclo “for”

{
textcolor(i+1);
gotoxy(45,fila);cprintf("%c",nom[i]);

Impresión del nuevo vector
invertido y con color

fila=fila+1;
}

Cierre del ciclo y de la
función

}
void main()

Función principal e inicio

{
do

Inicio del ciclo “do-while”

{
clrscr();

Limpiado de pantalla y
llamado de la función borde

borde();
gotoxy(32,2);printf("**Cadena de Caracteres Invertida**");

Impresión de mensajes

gotoxy(27,8);printf("Vector");
gotoxy(43,8);printf("Inversion");

Llamado de la función
global

inver();
159
gotoxy(12,22);printf("Digite 1 para continuar o 0 para salir : ");scanf("%d",&op);
}while(op==1);

Cierre del ciclo

getch();

Pausa y cierre del
programa

}

CORRIDO DEL PROGRAMA:

160
54.- Diseñe 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 librerías declaro dos variables tipo carácter y 7 variables de tipo entero
utilizo 3 funciones la primera para el diseño del borde en pantalla la segunda función
para sacar el proceso de encontrar las consonantes y la tercera función es la principal
utilizo un do while para repetir el proceso
CODIFICACION
#include<conio.h>

LIBRERIAS

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

FUNCIÓN BORDE

for(i=1;i<=80;i++)
{
gotoxy(i,1);cprintf("*");
gotoxy(i,24);cprintf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);cprintf("*");

//IMPRECION DE *

gotoxy(80,i);cprintf("*");
} //FIN DEL CICLO FOR 
} // FIN DEL CICLO DE LA FUNCION DEL BORDE //
void caracter()
{

FUNCION PARA SACAR CONSONANTES

gotoxy(5,5);printf("Cadena:");gets(cad); //IMPRIMO UN MENSAJE CON LA PALABRA CADENA

161
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("%cn",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

162
{ // 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 CARÁCTER
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 DEL PROGRAMA

163
56.- Diseñe 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 números primos
y asignarlos a un nuevo vector, presente el vector resultante ordenado en
forma ascendente y descendente.

ANÁLISIS
1. Codificamos el borde dentro de una funciones
2. Dentro de otra funciones ingresamos un límite y un factor
3. Si la posiciones es par debemos condicionar el valor ingresado entre 3 y
23
4. Si la posiciones es impar realizamos el proceso para que se genere el
factor
5. Realizamos otra función para imprimir los números 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 función para ordenar de forma ascendente los valores
asignados al vector de números primos
8. De igual manera utilizamos una función para ordenar de forma
descendente los valores asignados al vector de los números primos.
9. Abrimos la función del programa principal
10. Llamamos las funciones previamente codificadas
DOCUMENTACIÓN
Librerías
Declaración de Variables int
Inicio de función borde

Lazo For

Fin de función

#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);
gotoxy(i,1);cprintf("*");
gotoxy(i,24);cprintf("*");
}
for(i=1;i<=24;i++)
{
textcolor(i);
gotoxy(1,i);cprintf("*");
gotoxy(80,i);cprintf("*");
}
}
164
Función de ingreso
Ingresos e impresiones

Inicializaciones
Lazo For

Fin de función
Funciones primos
Inicialización variables

Lazo For

Condición If

Fin función

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

165
Función Ascendente
Lazo For

Fin de función
Función descendente
Lazo for

Fin de función

Función principal

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");
gotoxy(40,fila);printf("%d",vec[i]);
fila=fila+1;
}
}//cierre
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");
gotoxy(65,fila);printf("%d",vec[i]);
fila=fila+1;
}
}//cierre

void main()
{
166
Llamado de funciones

Lazo Do While
Fin de función

do
{
clrscr();
borde();
ingreso();
primos();
ascendente();
descendente();
getch();
gotoxy(10,22);printf("Presione 1/0>>
");scanf("%d",&op);
}while(op==1);
}

CORRIDO DEL PROGRAMA

167
57.-

Diseñe un programa utilizando funciones y matrices que me permita
visualizar los datos en una matriz y otra matriz resultante con los datos
ingresados.
ANÁLISIS
En este programa utilizaremos funciones tanto para el borde como para
ingresar y presentar los datos de nuestra matriz, esencialmente la utilización 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.
DOCUMENTACION
#include<stdio.h>
Librerías
#include<conio.h>
int j,i,k,op,matriz1[10][10],col=10,fila=8,limite,datos,sali,f;
Declaración de variables
void borde()
{
for(k=2;k<=80;k++)
{
gotoxy(k,2);printf("-");
gotoxy(k,24);printf("-");
}
Función para el diseño del borde
for(k=2;k<=24;k++)
{
gotoxy(2,k);printf("-");
gotoxy(80,k);printf("-");
}
}
void ing(int datos)
{
col=10;
fila=8;
for(i=1;i<=limite;i++)
{
Función para el ingreso de los
for(j=1;j<=limite;j++)
{
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++)
Función para la impresión de
{
for(j=1;j<=limite;j++)
nuestra matriz utilizando ciclos
FOR
168
{
gotoxy(col,fila); printf("%d",matriz1[i][j]);
col=col+5;
}
col=40;
fila=fila+1;
}
}
Cuerpo principal del programa
void main()
{
do
Ciclo DO-while para repetir n veces
{
clrscr();
Blanqueo de pantalla
borde();

Llamado de la función del borde

gotoxy(3,3); printf("Ingrese un límite: "); 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 pantalla
}

CORRIDO DEL PROGRAMA

169

Ingreso del límite de datos

Ciclo DO-while para repetir n
veces
58.- Diseñe 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 librerías y las variables globales abrimos una función 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
función del programa ingresamos en una variable para que se almacene el
factor, también 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 función para llamar al proceso ingreso un lazo repetitivo,
un limpiador de pantalla,llamo a la función 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.

DOCUMENTACION

#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++)
{
gotoxy(i,1);cprintf("*");
gotoxy(i,24);cprintf("*");
}
PROCESO DEL BORDE
for(i=1;i<=24;i++)
{
gotoxy(1,i);cprintf("*");
gotoxy(80,i);cprintf("*");
}
}
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);
170

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
gotoxy(columna,fila);printf("%d",matriz[i][j]);
EL FACTOR
columna=columna+4;
}
columna=50;
fila=fila+2;
}
}
SE CIERRA LA FUNCION
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
171
CORRIDO DEL PROGRAMA

172
59.- Diseñe un programa utilizando funciones y matrices que me permita Imprimir una
matriz cuadrática de ceros excepto la diagonal principal.
ANALISIS
Ingresamos las librerías introducimos las variables globales abrimos la función del
borde ingresamos un textcolor(YELLOW); para darle color al diseño mediante lazos for
asemos el margen de la pantalla y cerramos la función abrimos la función del
programa para la matriz visualizamos el límite que se desea ingresar ingresamos dos
lazos for con (i,j) para formar a la matriz, ingresamos una condición si el número de la
fila es igual al de la columna se imprima con unos caso contrario de ceros cerramos la
función. 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.
DOCUMENTACION
#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++)
{
gotoxy(i,1);cprintf("*");
gotoxy(i,24);cprintf("*");
}
for(i=1;i<=24;i++)
PROCESO DEL BORDE
{
gotoxy(1,i);cprintf("*");
gotoxy(80,i);cprintf("*");
}
}
CIERRO LA FUNCION
void programa(int datos)
FUNCION DEL PROGRAMA
{
ABRIR LA FUNCION
gotoxy(3,5);cprintf("Limite: ");cscanf("%d",&limite);
INGRESAR UN LIMITE
for(i=1;i<=limite;i++)
{
ORDENAR LA MATRIZ
for(j=1;j<=limite;j++)
{
if(i==j)
{
matriz[i][j]=1;
173
gotoxy(columna,fila);cprintf("%d",matriz[i][j]);
REALIZA UNA CONDICION
columna=columna+5;
}
else
{
matriz[i][j]=0;
gotoxy(columna,fila);printf("%d",matriz[i][j]);
columna=columna+5;
CASO CONTRARIO
}
}
fila=fila+1;
columna=13;
}
}
SE CIERRA LA FUNCION
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
}
SE CIERRA LA FUNCION

CORRIDO DEL PROGRAMA

174
61.- Diseñe 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.
ANÁLISIS
Para este programa utilizamos funciones para llamar al procedimiento para
realizar el ejercicio también 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.
DOCUMENTACIÓN

#include<conio.h>

Librerías

#include<stdio.h>
Declaración de variables

int fil, col, aux, i, j, mat[10][10], vect[10], lim, op, a, b, c, h;
void bdob()
{
int i;
clrscr();
gotoxy(1,1);printf("É");
gotoxy(80,1);printf("»");
for(i=2;i<=79;i++)

Función global para el
borde

{
gotoxy(i,1);printf("Í");
gotoxy(i,24);printf("Í");
}
gotoxy(1,24);printf("È");
gotoxy(80,24);printf("¼");
for(i=2;i<=23;i++)
{
175
gotoxy(1,i);printf("º");
gotoxy(80,i);printf("º");
}
}
void diag()
Inicio de la función para
determinar las diagonales

{
col=5;
fil=8;
a=1;
b=0;
c=0;

Condición para calcular las
diagonales

for(i=1;i<=lim;i++)
{
for(j=1;j<=lim;j++)
{
c=a+b;
a=b;
b=c;

Proceso para calcular la
serie del fibonasi

mat[i][j]=c;
gotoxy(col,fil);printf("%d",mat[i][j]);
col=col+4;
}
col=5;
fil=fil+3;
}
}

176
void dprinc()
{

Inicio de la función calcular
la diagonal principal

col=21;
fil=8;
h=1;
for(i=1;i<=lim;i++)
{

Condición para calcular la
diagonal

for(j=1;j<=lim;j++)
{
if(i==j)
{
vect[h]=mat[i][j];
h=h+1;
gotoxy(col,fil);printf("%d",mat[i][j]);

Imprimimos la matriz

col=col+4;
}
}
fil=fil+3;
}
}
void dsec()
{

Función para calcular la
diagonal secundaria

col=28;
fil=8;
j=lim;

for(i=1;i<=lim;i++)

177
{
vect[h]=mat[i][j];
h=h+1;
gotoxy(col,fil);printf("%d",mat[i][j]);
j=j-1;
Imprimimos la matriz

col=col-4;
fil=fil+3;
}
}
void diag_vect()
{
fil=8;
for(i=1;i<h;i++)
{
gotoxy(41,fil);printf("%d",vect[i]);
fil=fil+2;
}
}
void orden()
{

Función para ordenar las
diagonales.

fil=8;
for(i=1;i<h;i++)
{
for(j=1;j<h;j++)
{
if(vect[i]<vect[j])
{

178
aux=vect[i];
vect[i]=vect[j];
vect[j]=aux;
}
}
}
fil=8;
Calculamos el vector
descendente

for(i=1;i<h;i++)
{
gotoxy(56,fil);printf("%d",vect[i]);
fil=fil+2;
}
for(i=1;i<h;i++)

Proceso para ordenar

{
for(j=1;j<h;j++)
{
if(vect[i]>vect[j])
{
aux=vect[i];

Calculamos el vector
ascendente

vect[i]=vect[j];
vect[j]=aux;
}
}
}
fil=8;
for(i=1;i<h;i++)
{

179
gotoxy(71,fil);printf("%d",vect[i]);
fil=fil+2;
}
}
void main()
{
do
{

Función donde a
proseguimos a imprimir
los datos

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>>");
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();
}
180
CORRIDO DEL PROGRAMA

BIBLIOGRAFIA
http://asesoria.blogcindario.com/2008/08/00003-elementos-del-lenguaje-c.html
http://recursotec.latinowebs.com/lecciones/c/source/capitulo2-1.htm
http://www.slideshare.net/yesid19/elementos-basicos-del-lenguaje-c
181

Libro digital de programación

  • 1.
    Las Generalidades dela Programación Estructurada Turbo C++ 07 de Enero de 2014 Universidad Técnica de Ambato Estefanía Sánchez Núñez
  • 2.
    INDICE Tabla de contenido ¿Quées el Turbo C++? .................................................................................................................4 CARACTERÍSTICAS ................................................................................................................1 ELEMENTOS BÁSICOS DEL LENGUAJE C ........................................................................2 ESTRUCTURA ..........................................................................................................................4 COMENTARIOS ........................................................................................................................5 IDENTIFICADORES .................................................................................................................6 TIPOS DE DATOS ....................................................................................................................6 SALIDA / ENTRADA ...............................................................................................................11 SENTENCIAS CONDICIONALES ........................................................................................14  Estructura IF...ELSE ..................................................................................................14  Estructura SWITCH ...................................................................................................15 BUCLES ...................................................................................................................................16  Sentencia WHILE .......................................................................................................16 Sentencia DO...WHILE .......................................................................................................17 Sentencia FOR ....................................................................................................................18 Sentencia BREAK ...............................................................................................................19 Sentencia CONTINUE ........................................................................................................19 FUNCIONES ............................................................................................................................20  Funciones ....................................................................................................................21 VECTORES..............................................................................................................................25 MATRICES ...............................................................................................................................28 LIBRERÍAS...............................................................................................................................33 Librería stdio.h .....................................................................................................................33 Librería stdlib.h ....................................................................................................................34 Librería conio.h ....................................................................................................................34 Librería string.h ....................................................................................................................35 BIBLIOGRAFIA ........................................................................................................................95 2
  • 3.
    INTRODUCCIÓN C es unlenguaje de programación de propósito general que ofrece economía sintáctica, control de flujo y estructuras sencillas y un buen conjunto de operadores. No es un lenguaje de muy alto nivel y más bien un lenguaje pequeño, sencillo y no está especializado en ningún tipo de aplicación. Esto lo hace un lenguaje potente, con un campo de aplicación ilimitado y sobre todo, se aprende rápidamente. En poco tiempo, un programador puede utilizar la totalidad del lenguaje. 3
  • 4.
    ¿Qué es elTurbo C++? Turbo C es un Entorno de desarrollo integrado y compilador para programar en lenguaje C, desarrollado por Borland. El Turbo C++ es un lenguaje de programación que nos ayuda a desarrollar aplicaciones de distintos tipos, como por ejemplo: juegos programas educativos, científicos y hasta de administración de bases de dato. El Turbo C++ se utiliza bajo el sistema operativo DOS, pero se puede acceder a él desde windows. Normalmente cuando se instala el Turbo C++ sus archivos se almacenan dentro de una carpeta llamada TC. 4
  • 5.
    CARACTERÍSTICAS  El lenguaje Cse conoce como un lenguaje compilado. Existen dos tipos de lenguaje: interpretados y compilados. Los interpretados son aquellos que necesitan del código fuente para funcionar. Ejemplo: Basic. Los compilados convierten el código fuente en un fichero objeto y éste en un fichero ejecutable.  Podemos decir que el lenguaje C es un lenguaje de nivel medio, ya que combina elementos de lenguaje de alto nivel con la funcionalidad del lenguaje ensamblador. Es un lenguaje estructurado, ya que permite crear procedimientos en bloques dentro de otros procedimientos. Hay que destacar que el C es un lenguaje portable, ya que permite utilizar el mismo código en diferentes equipos y sistemas informáticos: el lenguaje es independiente de la arquitectura de cualquier máquina en particular.  Por último solo queda decir que el C es un lenguaje relativamente pequeño; se puede describir en poco espacio y aprender rápidamente. 1
  • 6.
    ELEMENTOS BÁSICOS DELLENGUAJE C Un programa en C++ está definido por funciones, grupo de instrucciones que pueden o no hacer algún cálculo, donde la función principal debe ser llamada main. La composición general de un programa en C++ es: Directivas de pre procesamiento Declaración global Función main Funciones definidas po Comentarios para entender el funcionamiento del programar el usuario 2
  • 7.
     Directivas Las directivasde pre procesamiento son definidas para que el compilador realice algo antes de compilar el programa, revisar si la sintaxis es correcta y generar un código ejecutable por la computadora, como el incluir funciones de alguna biblioteca conocida. La directiva para incluir bibliotecas es como las siguientes: Ejemplo: #include <iostream.h> Esta directiva permitirá utilizar la función de lectura cin y la función de escritura cout propias de C++. #include <stdio.h> Esta directiva permitirá utilizar las funciones de lectura y escritura propias de C.  Declaraciones Globales Las declaraciones globales son definiciones de variables o constantes que serán utilizadas por cualquiera de todas las funciones definidas en el programa. La sintaxis para la declaración de una variable es: Tipo var1, var2,..., var3; o bien Tipo var1= valor, var2,..., var3;  Función main La función main( ), es obligatoria en cada programa C, C++. Indica el comienzo del programa y requiere los paréntesis ( ) a continuación de main( ).  Funciones definidas por el usuario La definición de una función se realiza escribiendo primero el tipo del valor de retorno de la función, después el nombre de la función, posteriormente entre paréntesis las variables que utilizará dicha función, parámetros, y finalmente las instrucciones de la función. 3
  • 8.
    Ejemplo: double promedio (int a, int b, int c) { return (a + b + c ) / 3.0; } Declara a la función promedio, la cual recibe tres valores enteros y calcula y regresa el promedio de ellos.  Comentarios Los comentarios pueden escribirse utilizando alguna de las siguientes formas: comentando en la misma línea, utiliza //, Ejemplo: int edad; // la edad se utilizará como un valor entero. Comentando entre varias líneas, utiliza /* */, ESTRUCTURA Todo programa en C consta de una o más funciones, una de las cuales se llama main. El programa comienza en la función main, desde la cual es posible llamar a otras funciones. Cada función estará formada por la cabecera de la función, compuesta por el nombre de la misma y la lista de argumentos, la declaración de las variables a utilizar y la secuencia de sentencias a ejecutar. Ejemplo: declaraciones globales main( ) { variables locales bloque } funcion1( ) { variables locales bloque } 4
  • 9.
    COMENTARIOS A la horade programar es conveniente añadir comentarios para poder saber que función tiene cada parte del código, en caso de que no lo utilicemos durante algún tiempo. Además facilitaremos el trabajo a otros programadores que puedan utilizar nuestro archivo fuente. Para poner comentarios en un programa escrito en C usamos los símbolos /*y */: /* Este es un ejemplo de comentario */ /* Un comentario también puede Estar escrito en varias líneas */ El símbolo /* se coloca al principio del comentario y el símbolo */ al final. El comentario, contenido entre estos dos símbolos, no será tenido en cuenta por el compilador. Palabras clave Existen una serie de indicadores reservados, con una finalidad determinada, que no podemos utilizar como identificadores. A continuación vemos algunas de estas palabras clave: char int float double if else do while short long extern static default break sizeof continue for register typedef 5 switch
  • 10.
    IDENTIFICADORES Un identificador esel nombre que damos a las variables y funciones. Está formado por una secuencia de letras y dígitos, aunque también acepta el carácter de subrayado. Por contra no acepta los acentos ni la ñ/Ñ. El primer carácter de un identificador no puede ser un número, es decir que debe ser una letra o el símbolo. Se diferencian las mayúsculas de las minúsculas, así num, Num y nuM son distintos identificadores. TIPOS DE DATOS  Enteros Dentro de los enteros están los tipos: short, int, long, los cuales varían en rango de acuerdo al compilador que se utilice, siendo long rango mayor y short el de menor.  Flotantes Dentro de los flotantes C++ tiene los tipos: float, double y long double donde al igual que los enteros varía el rango de cada uno de acuerdo al compilador que se utilice. De igual forma el float es el de menor rango siendo long double el de rango mayor.  Caracteres Se utiliza el tipo char. Para representar un carácter en C++ se utilizan apóstrofes. Ejemplos: „a‟, „b‟ , „5‟ Para representar una cadena de caracteres se utilizan las comillas. Ejemplo: “soy una cadena” 6
  • 11.
    TIPO char int float double Tamaño 1 byte 2 bytes 4bytes 8 bytes Rango de valores -128 a 127 -32768 a 32767 3'4 E-38 a 3'4 E+38 1'7 E-308 a 1'7 E+308 Calificadores de tipo Los calificadores de tipo tienen la misión de modificar el rango de valores de un determinado tipo de variable. Estos calificadores son cuatro:  signed Le indica a la variable que va a llevar signo. Es el utilizado por defecto. Tamaño signed char 1 byte signed int 2 bytes Rango de valores -128 a 127 -32768 a 32767  unsigned Le indica a la variable que no va a llevar signo (valor absoluto). Tamaño unsigned char 1 byte unsigned int 2 bytes rango de valores 0 a 255 0 a 65535  short Rango de valores en formato corto (limitado). Es el utilizado por defecto. Tamaño short char short int 1 byte 2 bytes rango de valores -128 a 127 -32768 a 32767  long Rango de valores en formato largo (ampliado). Tamaño long int 4 bytes long double 10 bytes rango de valores -2.147.483.648 a 2.147.483.647 -3'36 E-4932 a 1'18 E+4932 También es posible combinar calificadores entre sí: signed long int = long int = long unsigned long int = unsigned long 4 bytes 0 a 4.294.967.295 El mayor entero permitido en 'C' 7
  • 12.
    Las variables Una variablees un tipo de dato, referenciado mediante un identificador llamado de la variable. Su contenido podrá ser modificado a lo largo del programa. Una variable sólo puede pertenecer a un tipo de dato. Para poder utilizar una variable, primero tiene que ser declarada: [calificador] <tipo> <nombre> Es posible inicializar y declarar más de una variable del mismo tipo en la misma sentencia: [calificador]<tipo><nombre1>,<nombre2>=<valor>,<nombre3>=<valor>,<no mbre4> Ejemplo: /* Uso de las variables */ #include <stdio.h> main() /* Suma dos valores */ { int num1=4,num2,num3=6; printf("El valor de num1 es %d",num1); printf("nEl valor de num3 es %d",num3); num2=num1+num3; printf("nnum1 + num3 = %d",num2); } ¿Dónde se declaran? Las variables pueden ser de dos tipos según el lugar en que las declaremos: globales o locales. La variable global se declara antes de la main( ). Puede ser utilizada en cualquier parte del programa y se destruye al finalizar éste. 8
  • 13.
    La variable localse declara después de la main( ), en la función en que vaya a ser utilizada. Sólo existe dentro de la función en que se declara y se destruye al finalizar dicha función. El identificador, nombre de la variable, no puede ser una palabra clave y los caracteres que podemos utilizar son las letras: a-z y A-Z, la ñ o Ñ no está permitida, los números: 0-9 y el símbolo de subrayado. Además hay que tener en cuenta que el primer carácter no puede ser un número. Ejemplo: /* Declaración de variables */ #include <stdio.h> int a; main() /* Muestra dos valores */ { int b=4; printf("b es local y vale %d",b); a=5; printf("na es global y vale %d",a); } Constantes Al contrario que las variables, las constantes mantienen su valor a lo largo de todo el programa. Para indicar al compilador que se trata de una constante, usaremos la directiva #define: #define <identificador> <valor> Observa que no se indica el punto y coma de final de sentencia ni tampoco el tipo de dato. La directiva #define no sólo nos permite sustituir un nombre por un valor numérico, sino también por una cadena de caracteres. El valor de una constante no puede ser modificado de ninguna manera. Ejemplo: /* Uso de las constantes */ #include <stdio.h> #define pi 3.1416 9
  • 14.
    #define escribe printf main()/* Calcula el perímetro */ { int r; escribe("Introduce el radio: "); scanf("%d",&r); escribe("El perímetro es: %f",2*pi*r); } Secuencias de escape Ciertos caracteres no representados gráficamente se pueden representar mediante lo que se conoce como secuencia de escape. A continuación vemos una tabla de las más significativas: n salto de línea b retroceso t tabulación horizontal v tabulación vertical contrabarra f salto de página ' apóstrofe " comillas dobles 0 fin de una cadena de caracteres Ejemplo: /* Uso de las secuencias de escape */ #include <stdio.h> main() /* Escribe diversas sec. de escape */ { printf("Me llamo "Nemo" el grande"); 10
  • 15.
    printf("nDirección: C Mayor25"); printf("nHa salido la letra 'L'"); printf("nRetrocesob"); printf("ntEsto ha sido todo"); } Inclusión de ficheros En la programación en C es posible utilizar funciones que no estén incluidas en el propio programa. Para ello utilizamos la directiva #include, que nos permite añadir librerías o funciones que se encuentran en otros ficheros a nuestro programa. Para indicar al compilador que vamos a incluir ficheros externos podemos hacerlo de dos maneras, siempre antes de las declaraciones. 1. Indicándole al compilador la ruta donde se encuentra el fichero. #include "misfunc.h" #include "c:includesmisfunc.h" 2. Indicando que se encuentran en el directorio por defecto del compilador. #include <misfunc.h> SALIDA / ENTRADA  Sentencia printf( ) La rutina printf permite la aparición de valores numéricos, caracteres y cadenas de texto por pantalla. El prototipo de la sentencia printf es el siguiente: printf(control,arg1,arg2...); En la cadena de control indicamos la forma en que se mostrarán los argumentos posteriores. También podemos introducir una cadena de texto, sin necesidad de argumentos, o combinar ambas posibilidades, así como secuencias de escape. 11
  • 16.
    En el casode que utilicemos argumentos deberemos indicar en la cadena de control tantos modificadores como argumentos vayamos a presentar. El modificador está compuesto por el carácter % seguido por un carácter de conversión, que indica de qué tipo de dato se trata. Ejemplo: /* Uso de la sentencia printf() 1. */ #include <stdio.h> main() /* Saca por pantalla una suma */ { int a=20,b=10; printf("El valor de a es %dn",a); printf("El valor de b es %dn",b); printf("Por tanto %d+%d=%d",a,b,a+b); } Los modificadores más utilizados son: %c %d %u %o %x %e %f %s %p Un único carácter Un entero con signo, en base decimal Un entero sin signo, en base decimal Un entero en base octal Un entero en base hexadecimal Un número real en coma flotante, con exponente Un número real en coma flotante, sin exponente Una cadena de caracteres Un puntero o dirección de memoria Ejemplo: /* Uso de la sentencia printf() 2. */ #include <stdio.h> main() /* Modificadores 1 */ { char cad[]="El valor de"; int a=-15; unsigned int b=3; 12
  • 17.
    float c=932.5; printf("%s aes %dn",cad,a); printf("%s b es %un",cad,b); printf("%s c es %e o %f",cad,c,c); } El formato completo de los modificadores es el siguiente: % [signo] [longitud] [.precisión] [l/L] conversión Signo: indicamos si el valor se ajustará a la izquierda, en cuyo caso utilizaremos el signo menos, o a la derecha. Longitud: especifica la longitud máxima del valor que aparece por pantalla. Si la longitud es menor que el número de dígitos del valor, éste aparecerá ajustado a la izquierda. Precisión: indicamos el número máximo de decimales que tendrá el valor. l/L: utilizamos l cuando se trata de una variable de tipo long y L cuando es de tipo double. Ejemplo: /* Uso de la sentencia printf() 3. */ #include <stdio.h> main() /* Modificadores 2 */ { char cad[ ]="El valor de"; int a=25986; long int b=1976524; float c=9.57645; printf("%s a es %9dn",cad,a); printf("%s b es %ldn",cad,b); printf("%s c es %.3f",cad,c); }  Sentencia scanf( ) La rutina scanf permite entrar datos en la memoria del ordenador a través del teclado. 13
  • 18.
    El prototipo dela sentencia scanf es el siguiente: scanf(control,arg1,arg2...); En la cadena de control indicaremos, por regla general, los modificadores que harán referencia al tipo de dato de los argumentos. Al igual que en la sentencia printf los modificadores estarán formados por el carácter % seguido de un carácter de conversión. Los argumentos indicados serán, nuevamente, las variables. La principal característica de la sentencia scanf es que necesita saber la posición de la memoria del ordenador en que se encuentra la variable para poder almacenar la información obtenida. Para indicarle esta posición utilizaremos el símbolo ampersand &, que colocaremos delante del nombre de cada variable. Esto no será necesario en los arrays. Ejemplo: /* Uso de la sentencia scanf(). */ #include <stdio.h> main() /* Solicita dos datos */ { char nombre[10]; int edad; printf("Introduce tu nombre: "); scanf("%s",nombre); printf("Introduce tu edad: "); scanf("%d",&edad); } SENTENCIAS CONDICIONALES Este tipo de sentencias permiten variar el flujo del programa en base a unas determinadas condiciones. Existen varias estructuras diferentes:  Estructura IF...ELSE Sintaxis: if (condición) sentencia; La sentencia solo se ejecuta si se cumple la condición. En caso contrario el programa sigue su curso sin ejecutar la sentencia. 14
  • 19.
    Otro formato: if (condición)sentencia1; else sentencia2; Si se cumple la condición ejecutará la sentencia1, sinó ejecutará la sentencia2. En cualquier caso, el programa continuará a partir de la sentencia2. Ejemplo: /* Uso de la sentencia condicional IF. */ #include <stdio.h> main() /* Simula una clave de acceso */ { int usuario,clave=18276; printf("Introduce tu clave: "); scanf("%d",&usuario); if(usuario==clave) printf("Acceso permitido"); else printf("Acceso denegado"); }  Estructura SWITCH Esta estructura se suele utilizar en los menús, de manera que según la opción seleccionada se ejecuten una serie de sentencias. Su sintaxis es: switch (variable){ case contenido_variable1: sentencias; break; case contenido_variable2: sentencias; break; default: sentencias; } 15
  • 20.
    Cada case puedeincluir una o más sentencias sin necesidad de ir entre llaves, ya que se ejecutan todas hasta que se encuentra la sentencia BREAK. La variable evaluada sólo puede ser de tipo entero o caracter. default ejecutará las sentencias que incluya, en caso de que la opción escogida no exista. Ejemplo: /* Uso de la sentencia condicional SWITCH. */ #include <stdio.h> main() /* Escribe el día de la semana */ { int dia; printf("Introduce el día: "); scanf("%d",&dia); switch(dia){ case 1: printf("Lunes"); break; case 2: printf("Martes"); break; case 3: printf("Miércoles"); break; case 4: printf("Jueves"); break; case 5: printf("Viernes"); break; case 6: printf("Sábado"); break; case 7: printf("Domingo"); break; } } BUCLES Los bucles son estructuras que permiten ejecutar partes del código de forma repetida mientras se cumpla una condición. Esta condición puede ser simple o compuesta de otras condiciones unidas por operadores lógicos.  Sentencia WHILE Su sintaxis es: while (condición) sentencia; 16
  • 21.
    Con esta sentenciase controla la condición antes de entrar en el bucle. Si ésta no se cumple, el programa no entrará en el bucle. Naturalmente, si en el interior del bucle hay más de una sentencia, éstas deberán ir entre llaves para que se ejecuten como un bloque. Ejemplo: /* Uso de la sentencia WHILE. */ #include <stdio.h> main() /* Escribe los números del 1 al 10 */ { int numero=1; while(numero<=10) { printf("%dn",numero); numero++; } } Sentencia DO...WHILE Su sintaxis es: do{ sentencia1; sentencia2; }while (condición); Con esta sentencia se controla la condición al final del bucle. Si ésta se cumple, el programa vuelve a ejecutar las sentencias del bucle. La única diferencia entre las sentencias while y do-while es que con la segunda el cuerpo del bucle se ejecutará por lo menos una vez. Ejemplo: /* Uso de la sentencia DO...WHILE. */ #include <stdio.h>¡ main() /* Muestra un menú si no se pulsa 4 */ { char seleccion; 17
  • 22.
    do{ printf("1.- Comenzarn"); printf("2.- Abrirn"); printf("3.-Grabarn"); printf("4.- Salirn"); printf("Escoge una opción: "); seleccion=getchar(); switch(seleccion){ case '1':printf("Opción 1"); break; case '2':printf("Opción 2"); break; case '3':printf("Opción 3"); } }while(seleccion!='4'); } Sentencia FOR Su sintaxis es: for (inicialización;condición;incremento){ sentencia1; sentencia2; } La inicialización indica una variable de control que condiciona la repetición del bucle. Si hay más, van separadas por comas: for (a=1,b=100;a!=b;a++,b- -){ El flujo del bucle FOR transcurre de la siguiente forma: Ejemplo: /* Uso de la sentencia FOR. */ #include <stdio.h> main() /* Escribe la tabla de multiplicar */ { 18
  • 23.
    int num,x,result; printf("Introduce unnúmero: "); scanf("%d",&num); for (x=0;x<=10;x++){ result=num*x; printf("n%d por %d = %dn",num,x,result); } } Sentencia BREAK Esta sentencia se utiliza para terminar la ejecución de un bucle o salir de una sentencia SWITCH. Sentencia CONTINUE Se utiliza dentro de un bucle. Cuando el programa llega a una sentencia CONTINUE no ejecuta las líneas de código que hay a continuación y salta a la siguiente iteración del bucle. Y aquí termina el capítulo dedicado a los bucles. Existe otra sentencia, GOTO, que permite al programa saltar hacia un punto identificado con una etiqueta, pero el buen programador debe prescindir de su utilización. Es una sentencia muy mal vista en la programación en 'C'. Ejemplo: /* Uso de la sentencia CONTINUE. */ #include <stdio.h> main() /* Escribe del 1 al 100 menos el 25 */ { int numero=1; while(numero<=100) { if (numero==25) { numero++; 19
  • 24.
    continue; } printf("%dn",numero); numero++; } } FUNCIONES  Tiempo devida de los datos Según el lugar donde son declaradas puede haber dos tipos de variables. Globales: las variables permanecen activas durante todo el programa. Se crean al iniciarse éste y se destruyen de la memoria al finalizar. Pueden ser utilizadas en cualquier función. Locales: las variables son creadas cuando el programa llega a la función en la que están definidas. Al finalizar la función desaparecen de la memoria. Si dos variables, una global y una local, tienen el mismo nombre, la local prevalecerá sobre la global dentro de la función en que ha sido declarada. Dos variables locales pueden tener el mismo nombre siempre que estén declaradas en funciones diferentes. Ejemplo: /* Variables globales y locales. */ #include <stdio.h> int num1=1; main() /* Escribe dos cifras */ { int num2=10; printf("%dn",num1); printf("%dn",num2); } 20
  • 25.
     Funciones Las funcionesson bloques de código utilizados para dividir un programa en partes más pequeñas, cada una de las cuáles tendrá una tarea determinada. Su sintaxis es: tipo_función nombre_función (tipo y nombre de argumentos) { bloque de sentencias } Tipo función: puede ser de cualquier tipo de los que conocemos. El valor devuelto por la función será de este tipo. Por defecto, es decir, si no indicamos el tipo, la función devolverá un valor de tipo entero ( int ). Si no queremos que retorne ningún valor deberemos indicar el tipo vacío ( void ). Nombre función: es el nombre que le daremos a la función. Tipo y nombre de argumentos: son los parámetros que recibe la función. Los argumentos de una función no son más que variables locales que reciben un valor. Este valor se lo enviamos al hacer la llamada a la función. Pueden existir funciones que no reciban argumentos. Bloque de sentencias: es el conjunto de sentencias que serán ejecutadas cuando se realice la llamada a la función. Las funciones pueden ser llamadas desde la función main o desde otras funciones. Nunca se debe llamar a la función main desde otro lugar del programa. Por último recalcar que los argumentos de la función y sus variables locales se destruirán al finalizar la ejecución de la misma.  Declaración de las funciones Al igual que las variables, las funciones también han de ser declaradas. Esto es lo que se conoce como prototipo de una función. Para que un programa en C sea compatible entre distintos compiladores es imprescindible escribir los prototipos de las funciones. Los prototipos de las funciones pueden escribirse antes de la función main o bien en otro fichero. En este último caso se lo indicaremos al compilador mediante la directiva #include. En el ejemplo adjunto podremos ver la declaración de una función, prototipo. Al no recibir ni retornar ningún valor, está declarada como void en ambos lados. También vemos que existe una variable global llamada num. Esta variable es reconocible en todas las funciones del programa. Ya en la función main 21
  • 26.
    encontramos una variablelocal llamada num. Al ser una variable local, ésta tendrá preferencia sobre la global. Por tanto la función escribirá los números 10 y 5. Ejemplo: /* Declaración de funciones. */ #include <stdio.h> void funcion(void); /* prototipo */ int num=5; /* variable global */ main() /* Escribe dos números */ { int num=10; /* variable local */ printf("%dn",num); funcion(); /* llamada */ } void funcion(void) { printf("%dn",num); }  Paso de parámetros a una función Las funciones pueden retornar un valor. Esto se hace mediante la instrucción return, que finaliza la ejecución de la función, devolviendo o no un valor. En una misma función podemos tener más de una instrucción return. La forma de retornar un valor es la siguiente: return ( valor o expresión ); El valor devuelto por la función debe asignarse a una variable. De lo contrario, el valor se perderá. En el ejemplo puedes ver lo que ocurre si no guardamos el valor en una variable. Fíjate que a la hora de mostrar el resultado de la suma, en el printf, también podemos llamar a la función. Ejemplo: /* Paso de parámetros. */ #include <stdio.h> int suma(int,int); /* prototipo */ 22
  • 27.
    main() /* Realizauna suma */ { int a=10,b=25,t; t=suma(a,b); /* guardamos el valor */ printf("%d=%d",suma(a,b),t); suma(a,b); /* el valor se pierde */ } int suma(int a,int b) { return (a+b); } Paso de parámetros Existen dos formas de enviar parámetros a una función: Por valor: cualquier cambio que se realice dentro de la función en el argumento enviado, NO afectará al valor original de las variables utilizadas en la llamada. Es como si trabajáramos con una copia, no con el original. No es posible enviar por valor arrays, deberemos hacerlo por referencia. Por referencia: lo que hacemos es enviar a la función la dirección de memoria donde se encuentra la variable o dato. Cualquier modificación SI afectará a las variables utilizadas en la llamada. Trabajamos directamente con el original. Ejemplo: /* Paso por valor. */ #include <stdio.h> void intercambio(int,int); main() /* Intercambio de valores */ { int a=1,b=2; printf("a=%d y b=%d",a,b); intercambio(a,b); /* llamada */ printf("a=%d y b=%d",a,b); } void intercambio (int x,int y) { int aux; aux=x; x=y; 23
  • 28.
    y=aux; printf("a=%d y b=%d",x,y); } Paraenviar un valor por referencia se utiliza el símbolo &, ampersand, delante de la variable enviada. Esto le indica al compilador que la función que se ejecutará tendrá que obtener la dirección de memoria en que se encuentra la variable. Vamos a fijarnos en los ejemplos. En el ejemplo anterior podrás comprobar que antes y después de la llamada, las variables mantienen su valor. Solamente se modifica en la función intercambio-paso por valor. En el siguiente ejemplo las variables intercambian su valor tras la llamada de la función-paso por referencia. Las variables con un * son conocidas como punteros, el único dato en 'C' que puede almacenar una dirección de memoria. Ejemplo: /* Paso por referencia. */ #include <stdio.h> void intercambio(int *,int *); main() /* Intercambio de valores */ { int a=1,b=2; printf("a=%d y b=%d",a,b); intercambio(&a,&b); /* llamada */ printf("a=%d y b=%d",a,b); } void intercambio (int *x,int *y) { int aux; aux=*x; *x=*y; *y=aux; printf("a=%d y b=%d",*x,*y); } 24
  • 29.
    Los argumentos dela función main: La función main no podía ser menos y también puede recibir argumentos, en este caso desde el exterior. Los argumentos que puede recibir son: argc: es un contador. Su valor es igual al número de argumentos escritos en la línea de comandos, contando el nombre del programa que es el primer argumento. argv: es un puntero a un array de cadenas de caracteres que contiene los argumentos, uno por cadena. En este ejemplo vamos a ver un pequeño programa que escribirá un saludo por pantalla. El programa FUNCION6.EXE. Ejemplo: /* Argumentos de la main. */ #include <stdio.h> main(int argc,char *argv[]) /* argumentos */ { printf("nCurso de Programación en C - Copyright (c) 1997-2001, Sergio Pachon"); printf("Programa de ejemplo.nn"); if (argc<2) { printf("Teclee: funcion6 su_nombre"); exit(1); /* fin */ } printf("Hola %s",argv[1]); } VECTORES Un vector es un array unidimensional, es decir, sólo utiliza un índice para referenciar a cada uno de los elementos. Un array es un identificador que referencia un conjunto de datos del mismo tipo. Imagina un tipo de dato int; podremos crear un conjunto de datos de ese tipo y utilizar uno u otro con sólo cambiar el índice que lo referencia. El índice será un valor entero y positivo. En C los arrays comienzan por la posición 0. 25
  • 30.
    Su declaración será: tiponombre [tamaño]; El tipo puede ser cualquiera de los ya conocidos y el tamaño indica el número de elementos del vector, se debe indicar entre corchetes [ ]. En el ejemplo puedes observar que la variable i es utilizada como índice, el primer for sirve para rellenar el vector y el segundo para visualizarlo. Como ves, las posiciones van de 0 a 9, total 10 elementos. Ejemplo: /* Declaración de un array. */ #include <stdio.h> main() /* Rellenamos del 0 - 9 */ { int vector[10],i; for (i=0;i<10;i++) vector[i]=i; for (i=0;i<10;i++) printf(" %d",vector[i]); } Podemos inicializar, asignarle valores un vector en el momento de declararlo. Si lo hacemos así no es necesario indicar el tamaño. Su sintaxis es: tipo nombre []={ valor 1, valor 2...} Ejemplos: int vector[ ]={1,2,3,4,5,6,7,8}; char vector[ ]="programador"; char vector[ ]={'p','r','o','g','r','a','m','a','d','o','r'}; Una particularidad con los vectores de tipo char, cadena de caracteres, es que deberemos indicar en que elemento se encuentra el fin de la cadena mediante el carácter nulo (0). Esto no lo controla el compilador, y tendremos que ser nosotros los que insertemos este carácter al final de la cadena. Por tanto, en un vector de 10 elementos de tipo char podremos rellenar un máximo de 9, es decir, hasta vector[8]. Si sólo rellenamos los 5 primeros, hasta vector[4], debemos asignar el carácter nulo a vector[5]. Es muy sencillo: vector[5]='0'; . 26
  • 31.
    Ejemplo de cómose rellena un vector de tipo char. /* Vector de tipo char. */ #include <stdio.h> main() /* Rellenamos un vector char */ { char cadena[20]; int i; for (i=0;i<19 && cadena[i-1]!=13;i++) cadena[i]=getche( ); if (i==19) cadena[i]='0'; else cadena[i-1]='0'; printf("n%s",cadena); } Podemos ver que en el for se encuentran dos condiciones: 1.- Que no se hayan rellenado todos los elementos (i<19). 2.- Que el usuario no haya pulsado la tecla ENTER, cuyo código ASCII es 13. (cadena[x-i]!=13). También podemos observar una nueva función llamada getche( ), que se encuentra en conio.h. Esta función permite la entrada de un carácter por teclado. Después se encuentra un if, que comprueba si se ha rellenado todo el vector. Si es cierto, coloca el carácter nulo en el elemento nº20 (cadena[19]). En caso contrario tenemos el else, que asigna el carácter nulo al elemento que almacenó el carácter ENTER. En resumen: al declarar una cadena deberemos reservar una posición más que la longitud que queremos que tenga dicha cadena. Llamadas a funciones con arrays Como ya se comentó en el tema anterior, los arrays únicamente pueden ser enviados a una función por referencia. Para ello deberemos enviar la dirección de memoria del primer elemento del array. Por tanto, el argumento de la función deberá ser un puntero. Ejemplo: /* Envío de un array a una función. */ #include <stdio.h> void visualizar(int []); /* prototipo */ main() /* rellenamos y visualizamos */ { int array[25],i; 27
  • 32.
    for (i=0;i<25;i++) { printf("Elemento nº%d",i+1); scanf("%d",&array[i]); } visualizar(&array[0]); } void visualizar(int array[]) /* desarrollo */ { int i; for (i=0;i<25;i++) printf("%d",array[i]); } En el ejemplo se puede apreciar la forma de enviar un array por referencia. La función se podía haber declarado de otra manera, aunque funciona exactamente igual: declaración o prototipo void visualizar(int *); desarrollo de la función void visualizar(int *array) MATRICES Una matriz es un array multidimensional. Se definen igual que los vectores excepto que se requiere un índice por cada dimensión. Su sintaxis es la siguiente: tipo nombre [tamaño 1][tamaño 2]...; Una matriz bidimensional se podría representar gráficamente como una tabla con filas y columnas. La matriz tridimensional se utiliza, por ejemplo, para trabajos gráficos con objetos 3D. En el ejemplo puedes ver como se rellena y visualiza una matriz bidimensional. Se necesitan dos bucles para cada una de las operaciones. Un bucle controla las filas y otro las columnas. 28
  • 33.
    Ejemplo: /* Matriz bidimensional.*/ #include <stdio.h> main() /* Rellenamos una matriz */ { int x,i,numeros[3][4]; /* rellenamos la matriz */ for (x=0;x<3;x++) for (i=0;i<4;i++) scanf("%d",&numeros[x][i]); /* visualizamos la matriz */ for (x=0;x<3;x++) for (i=0;i<4;i++) printf("%d",numeros[x][i]); } Si al declarar una matriz también queremos inicializarla, habrá que tener en cuenta el orden en el que los valores son asignados a los elementos de la matriz. Ejemplos: int numeros[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; quedarían asignados de la siguiente manera: numeros[0][0]=1 numeros[0][1]=2 numeros[0][2]=3 numeros[0][3]=4 numeros[1][0]=5 numeros[1][1]=6 numeros[1][2]=7 numeros[1][3]=8 numeros[2][0]=9 numeros[2][1]=10 numeros[2][2]=11 numeros[2][3]=12 También se pueden inicializar cadenas de texto: char dias[7][10]={"lunes","martes","miércoles","jueves","viernes","sábado","domingo" }; 29
  • 34.
    Para referirnos acada palabra bastaría con el primer índice: printf("%s",dias[i]);  PUNTEROS Un puntero es una variable que contiene la dirección de memoria de otra variable. Se utilizan para pasar información entre una función y sus puntos de llamada. Declaración Su sintaxis es la siguiente: tipo *nombre; Donde nombre es, naturalmente, el nombre de la variable, y tipo es el tipo del elemento cuya dirección almacena el puntero. Operadores Existen dos operadores especiales para trabajar con punteros: & y *. El primero devuelve la dirección de memoria de su operando. Por ejemplo, si queremos guardar en el puntero x la dirección de memoria de la variable num, deberemos hacer lo siguiente: x=# El segundo devuelve el valor de la variable cuya dirección es contenida por el puntero. Este ejemplo sitúa el contenido de la variable apuntada por x, es decir num, en la variable a: a=*x; Asignación Los punteros se asignan igual que el resto de las variables. El programa ejemplo mostrará las direcciones contenidas en p1 y p2, que será la misma en ambos punteros. Ejemplo: /* Asignaciones de punteros. */ #include <stdio.h> main() /* Asignamos direcciones */ { int a; int *p1,*p2; 30
  • 35.
    p1=&a; p2=p1; printf("%p %p",p1,p2); } Aritmética dedirecciones Es posible desplazar un puntero recorriendo posiciones de memoria. Para ello podemos usar los operadores de suma, resta, incremento y decremento (+, -, ++, - -). Si tenemos un puntero ( p1 ) de tipo int ( 2 bytes ), apuntando a la posición 30000 y hacemos: p1=p1+5; el puntero almacenará la posición 30010, porque apunta 5 enteros por encima ( 10 bytes más ). Concepto de estructura Una estructura es un conjunto de una o más variables, de distinto tipo, agrupadas bajo un mismo nombre para que su manejo sea más sencillo. Su utilización más habitual es para la programación de bases de datos, ya que están especialmente indicadas para el trabajo con registros o fichas. La sintaxis de su declaración es la siguiente: { tipo_variable nombre_variable1; tipo_variable nombre_variable2; tipo_variable nombre_variable3; }; Donde tipo-estructura es el nombre del nuevo tipo de dato que hemos creado. Por último, tipo-variable y nombre-variable son las variables que forman parte de la estructura. Para definir variables del tipo que acabamos de crear lo podemos hacer de varias maneras, aunque las dos más utilizadas son éstas: Una forma de definir la estructura: struct trabajador { char nombre[20]; char apellidos[40]; int edad; 31
  • 36.
    char puesto[10]; }; struct trabajadorfijo, temporal; Otra forma: struct trabajador { char nombre[20]; char apellidos[40]; int edad; char puesto[10]; }fijo, temporal; En el primer caso declaramos la estructura, y en el momento en que necesitamos las variables, las declaramos. En el segundo las declaramos al mismo tiempo que la estructura. El problema del segundo método es que no podremos declarar más variables de este tipo a lo largo del programa. Para poder declarar una variable de tipo estructura, la estructura tiene que estar declarada previamente. Se debe declarar antes de la función main. El manejo de las estructuras es muy sencillo, así como el acceso a los campos o variables de estas estructuras. La forma de acceder a estos campos es la siguiente: variable.campo; Donde variable es el nombre de la variable de tipo estructura que hemos creado, y campo es el nombre de la variable que forma parte de la estructura. Lo veremos mejor con un ejemplo basado en la estructura definida anteriormente: temporal.edad=25; Almacena el valor 25 en el campo edad de la variable temporal de tipo trabajador. Otra característica interesante de las estructuras es que permiten pasar el contenido de una estructura a otra, siempre que sean del mismo tipo naturalmente: fijo=temporal; Al igual que con los otros tipos de datos, también es posible inicializar variables de tipo estructura en el momento de su declaración: 32
  • 37.
    struct trabajador fijo={"Pedro","HernándezSuárez", 32, "gerente"}; Si uno de los campos de la estructura es un array de números, los valores de la inicialización deberán ir entre llaves: struct notas { char nombre[30]; int notas[5]; }; struct notas alumno={"Carlos Pérez",{8,7,9,6,10}}; LIBRERÍAS Librería stdio.h printf Función: Escribe en la salida estándar con formato. Sintaxis: printf(formato , arg1 , ...); scanf Función: Lee de la salida estándar con formato. Sintaxis: scanf(formato , arg1 , ...); puts Función: Escribe una cadena y salto de linea. Sintaxis: puts(cadena); gets Función: Lee y guarda una cadena introducida por teclado. Sintaxis: gets(cadena); fopen Función: Abre un fichero en el modo indicado. Sintaxis: pf=fopen(fichero , modo); fclose Función: Cierra un fichero cuyo puntero le indicamos. Sintaxis: fclose(pf); fprintf Función: Escribe con formato en un fichero. Sintaxis: fprintf(pf , formato , arg1 , ...); fgets 33
  • 38.
    Función: Lee unacadena de un fichero. Sintaxis: fgets(cadena , longitud , pf); Librería stdlib.h atof Función: Convierte una cadena de texto en un valor de tipo float. Sintaxis: numflo=atof(cadena); atoi Función: Convierte una cadena de texto en un valor de tipo entero. Sintaxis: nument=atoi(cadena); itoa Función: Convierte un valor numérico entero en una cadena de texto. La base generalmente será 10, aunque se puede indicar otra distinta. Sintaxis: itoa(número , cadena , base); exit Función: Termina la ejecución y abandona el programa. Sintaxis: exit(estado); /* Normalmente el estado será 0 */ Librería conio.h clrscr Función: Borra la pantalla. Sintaxis: clrscr( ); clreol Función: Borra desde la posición del cursor hasta el final de la linea. Sintaxis: clreol( ) gotoxy Función: Cambia la posición del cursor a las coordenadas indicadas. Sintaxis: gotoxy(columna , fila); textcolor Función: Selecciona el color de texto (0 - 15). Sintaxis: textcolor(color); textbackground Función: Selecciona el color de fondo (0 - 7). Sintaxis: textbackground(color); wherex Función: Retorna la columna en la que se encuentra el cursor. 34
  • 39.
    Sintaxis: col=wherex( ); wherey Función:Retorna la fila en la que se encuentra el cursor. Sintaxis: fila=wherey( ); getch Función: Lee y retorna un único caracter introducido mediante el teclado por el usuario. No muestra el caracter por la pantalla. Sintaxis: letra=getch( ); Librería string.h strlen Función: Calcula la longitud de una cadena. Sintaxis: longitud=strlen(cadena); strcpy Función: Copia el contenido de una cadena sobre otra. Sintaxis: strcpy(copia , original); strcat Función: Concatena dos cadenas. Sintaxis: strcat(cadena1 , cadena2); strcmp Función: Compara el contenido de dos cadenas. Si cadena1 < cadena2 retorna un número negativo. Si cadena1 > cadena2, un número positivo, y si cadena1 es igual que cadena2 retorna 0 ( o NULL ). Sintaxis: valor=strcmp(cadena1 , cadena2); 35
  • 40.
    FUNDAMENTOS DE PROGRAMACIÓN Programa.-Conjunto de sentencias ordenadas secuencialmente para generar procesos automáticos. Datos de entrada ELEMENTOS DE UN PROGRAMA Resultados o Datos de salida Procesos Lenguaje de Programación.- Sintaxis que permite generar instrucciones para desarrollar aplicaciones. Librerías Palabras reservadas Identificadores ELEMENTOS DE UN LENGUAJE DE PROGRAMACIÓN 36
  • 41.
    PARTES DE UNPROGRAMA  Librerías.- Es una colección de clases y funciones, escritas en el núcleo del lenguaje. #include<conio.h> #include<stdio.h> #include<stdlib.h> #include<math.h>  Variables.- son un tipo de dato, referenciado mediante un identificador llamado de la variable. Su contenido podrá ser modificado a lo largo del programa. int op, j, a, b, c, d, v; float c, v, vt, s, su ,total; char p[15];  Función main.- Indica el comienzo del programa y requiere los paréntesis ( ) a continuación de main( ) o void main (). main () { viod main () {  Función clrscr.- Limpia la pantalla. clrscr();  Impresión de dados. gotoxy(15,2);printf("SUMA DE DOS NUMEROS"); gotoxy(15,14);printf("Eltotal de la suma es = %d ",c);  Lectura de variables.- Lee cualquier carácter, numero o símbolo incrasado desde teclado. gotoxy(6,6);printf("Ingrese un número: ");scanf("%d",&a); gotoxy(6,8);printf("Ingrese otro número: ");scanf("%d",&b);  Funciones.- Las funciones son bloques de código utilizados para dividir un programa en partes más pequeñas, cada una de las cuáles tendrá una tarea determinada. 37
  • 42.
    void nun () { if(a>b && a>c) { gotoxy(16,14);printf("%d",a); } else { if(b<a && b>c) { gotoxy(16,15);printf("%d",b); } else { gotoxy(16,16);printf("%d",c); } } } nun ();  Estructura SWITCH.- Esta estructura se suele utilizar en los menús, de manera que según la opción seleccionada se ejecuten una serie de sentencias. switch(op) { case 1: break; case 2: break; case 5: exit; break; }  Procesos.- Suma, resta, multiplicación, división, potencia, radicación. p=r*t; total=r/2.3  Sentencia do while.- Proceso de repetición. do { }while (op==1) 38
  • 43.
     Sentencias “for” pararealizar el borde. for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } }  getch.- Esperar a que el usuario presione una tecla para saltar a la siguiente instruccion o finalizar el programa si es que ya no quedan sentencias. getche();  Sentencia IF...ELSE.- solo se ejecuta si se cumple la condición. En caso contrario el programa sigue su curso sin ejecutar la sentencia. if(d>=7) { gotoxy(6,15);printf("Aprobado"); } else { gotoxy(6,15);printf("Suspenso"); }  return.- es una sentencia la cual tiene como finalidad indicarle al compilador que tiene que regresar el valor de retorno que tú le indiques. return(0); 39
  • 44.
    Programa Nº1  Diseñeun programa que me permita ingresar un número entero desde teclado de 1 a 7, y q me visualice el nombre del día de la semana que me corresponda. Análisis.- Utilizamos una variable de tipo entera para ingresar por teclado, la sentencia do-while para regresar si el número un no está entre 1-7, un swich para las opciones de los siete días e imprimimos por pantalla el día correspondiente según el número ingresado. DOCUMENTACION #include<stdio.h> #include<conio.h> int a; main () { clrscr(); gotoxy(25,3);printf("DIAS DE LA SEMANA"); do { gotoxy(29,5);printf(" "); gotoxy(10,5);printf("Ingrese un número: ");scanf("%d",&a); }while(a<1 || a>7); switch(a) { case 1: gotoxy(10,7);printf("Lunes"); break; case 2: gotoxy(10,7);printf("Martes"); break; case 3: gotoxy(10,7);printf("Miercoles"); break; case 4: gotoxy(10,7);printf("Jueves"); break; case 5: gotoxy(10,7);printf("Viernes"); break; case 6: gotoxy(10,7);printf("Sábado"); break; case 7: gotoxy(10,7);printf("Domingo"); break; } 40 LIBRERIAS VARIABLES INICIO LECTURA DE VARIABLES SENTENCIA SWICH
  • 45.
  • 46.
    Programa Nº2  Diseñeun programa que me permita ingresar 2 números por teclado y realizar la suma de los mismos Análisis.- Utilizamos tres variables de tipo entero, las dos para ingresar por teclado y la otra para realizar la suma, e imprimimos el resultado por pantalla. DOCUMENTACIÓN #include<stdio.h> #include<conio.h> int a,b,c; main () { clrscr(); gotoxy(15,2);printf("SUMA DE DOS NUMEROS"); gotoxy(6,6);printf("Ingrese un número: ");scanf("%d",&a); gotoxy(6,8);printf("Ingrese otro número: ");scanf("%d",&b); c=a+b; gotoxy(15,14);printf("Eltotal de la suma es = %d ",c); getche(); return(0); } 42 LIBRERIAS VARIABLES INICIO LECTURA DE VARIABLES FIN
  • 47.
    CORRIDO DEL PROGRAMA ProgramaNº3  Diseñe un programa que me permita ingresar 3 números 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 Análisis.- Utilizamos cuatro variables de tipo enteras, un do-wille para que las notas solo sean de 1-10, realizamos los procesos e imprimimos el resultado. DOCUMENTACIÓN #include<stdio.h> #include<conio.h> int a,b,c,d; main () { clrscr(); gotoxy(15,2);printf("PROMEDIO"); do { gotoxy(30,6);printf(" "); gotoxy(6,6);printf("Ingrese la primera nota: ");scanf("%d",&a); }while(a<0 || a>10); do { gotoxy(30,8);printf(" "); gotoxy(6,8);printf("Ingrese la segunda nota: ");scanf("%d",&b); 43 LIBRERIAS VARIABLES INICIO LECTURA DE VARIABLES
  • 48.
    }while(b<0 || b>10); do { gotoxy(30,10);printf(""); gotoxy(6,10);printf("Ingrese la tercera nota: ");scanf("%d",&c); }while (c<0 || c>10); d=(a+b+c)/3; gotoxy(6,14);printf("Promedio %d",d); if(d>=7) { gotoxy(6,15);printf("Aprobado"); } else { if(d>=5&&d<7) { gotoxy(6,15);printf("Suspenso"); } else { if(c<5) { gotoxy(6,15);printf("Reprobado"); }} } getche(); return(0); } CORRIDO DEL PROGRAMA 44 LECTURA DE VARIABLES CONDICIONAL “IF” FIN
  • 49.
  • 50.
    Programa Nº4  Diseñeun programa que realice la suma de dos números, siempre que el primer valor este entre 3 y 23 y el segundo valor este entre 5 y 17. Análisis.- Utilizamos tres variables de tipo enteras, dos do-while para que cumpla la condición requerida, realizamos el proceso y presentamos resultados DOCUMENTACIÓN #include<stdio.h> #include<conio.h> int a,b,c; main () { clrscr(); gotoxy(15,2);printf("SUMA DE DOS NUMEROS"); do { gotoxy(23,6);printf(" "); gotoxy(6,6);printf("Ingrese un n£mero: ");scanf("%d",&a); }while (a<3 || a>23); do { gotoxy(23,8);printf(" "); gotoxy(6,8);printf("Ingrese otro n£mero: ");scanf("%d",&b); }while (b<5 || b>17); c=a+b; gotoxy(15,14);printf("Eltotal de la suma es = %d ",c); getche(); return(0); } CORRIDO DEL PROGRAMA 46 LIBRERIAS VARIABLES INICIO LECTURA DE VARIABLES FIN
  • 51.
    Programa Nº5  Diseñeun 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. DOCUMENTACIÓN #include<stdio.h> #include<conio.h> main () { int a=1,b=0,oper; float c,p,v,s,t,f,g,r,q; do { clrscr(); a=1; b=0; gotoxy(30,2);printf("COMISIONES DE VENTAS"); gotoxy(5,5);printf("Ingresar el valor de la venta:");scanf("%f",&c); if((c>2999)&&(c<5001)) { p=(c*5)/100; v=c+p; gotoxy(8,10);printf("La venta total es=%f",v); gotoxy(8,13);printf("La ganancia es=%f",p); } if((c>5000)&&(c<8499)) 47 LIBRERIAS VARIABLES INICIO LECTURA DE VARIABLES
  • 52.
    { s=(c*7)/100; t=s+c; gotoxy(8,10);printf("La venta totales=%f",t); gotoxy(8,13);printf("La ganancia es=%f",s); } if((c>8500)&&(c<10001)) { r=(c*8)/100; q=r+c; gotoxy(8,10);printf("La venta total es=%f",q); gotoxy(8,13);printf("La ganancia es=%f",r); } if(c>10000) { f=(c*10)/100; g=f+c; gotoxy(8,10);printf("La venta total es=%f",g); gotoxy(8,13);printf("La ganancia es=%f",f); } gotoxy(30,20);printf("PRESS 1 para continuar o 0 abandonar"); scanf("%d",&oper); } while(oper==1); getch(); } CORRIDO DEL PROGRAMA 48 SENTECIA “IF” FIN
  • 53.
    Programa Nº6  Diseñeun 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 niño”  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. Análisis.- Utilizamos tres variables, una de tipo entera y otra de tipo carácter, sentencias if-else para realizar las equivalencias requeridas y un do-while para repetir el proceso. DOCUMENTACIÓN #include<stdio.h> #include<conio.h> #include<string.h> void main() { int ed,op; char nombre[15]; do { clrscr(); gotoxy(31,1);printf("Saber edad y equivalencia"); flushall(); gotoxy(10,3);printf("Ingrese nombre: ");gets(nombre); 49 LIBRERIAS VARIABLES INICIO LECTURA DE VARIABLES
  • 54.
    do { gotoxy(27,4);printf(" "); gotoxy(10,4);printf("Ingrese laedad: ");scanf("%d",&ed); }while(ed>85 || ed<3); if(ed>=3 && ed<=5) { gotoxy(10,7);printf("Es un bebe"); } else { if(ed>5 && ed<=13) SENTECIA “IF” { gotoxy(10,7);printf("Ni¤o"); } else { if(ed>15 && ed<=21) { gotoxy(10,7);printf("Adolecente"); } else { if(ed>21 && ed<=61) { gotoxy(10,7);printf("Adulto"); } else { gotoxy(10,7);printf("Adulto Mayor"); } } } } gotoxy(10,6);puts(nombre); gotoxy(10,10);printf("Presione 1 para continuar o 0 para salir: ");scanf("%d",&op); }while(op==1); getch(); FIN } } 50
  • 55.
  • 56.
    Programa Nº7  Diseñeun 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 según los productos que el usuario desee ingresar. Análisis.- Utilizamos 15 variables de tipo enteras, decimales y de caracte, un dowhile para que se repita el proceso, realizamos el proceso y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> VARIABLES main() { INICIO int op,j,a=4,b=4,c=4,d=4,v=0; float cant,vuni,vtotal,iva,s,sub,totalp; char p[15]; clrscr(); gotoxy(23,1); printf("SIMULACION DE FACTURA"); gotoxy(5,4); printf("Producto"); IMPRESION gotoxy(20,4); printf("Cantidad"); gotoxy(34,4); printf("Precio Unitario"); gotoxy(55,4); printf("Valor"); do { flushall(); a=a+1;gotoxy(5,a);gets(p); b=b+1;gotoxy(23,b);scanf("%2f",&cant); OPERASIONES c=c+1;gotoxy(39,c);scanf("%2f",&vuni); vtotal=cant*vuni; d=d+1;gotoxy(55,d);printf("%.2f",vtotal); v=v+vtotal; LECTURA DE gotoxy(2,24);printf("presione 1 para ingresar otro producto o 0 para finalizar la factura: ");scanf("%d",&op); }while(op==1); j=v; sub=j; gotoxy(45,21); printf("subtotal: %.2f",sub); iva=(sub*12)/100; IMPRESION gotoxy(50,22); printf("iva: %.2f",iva); vtotal=sub+iva; gotoxy(40,23); printf("valor a pagar: %.2f",vtotal); getch(); FIN } 52
  • 57.
  • 58.
    Programa Nº8  Diseñeun programa que me permita calcular el promedio general de las notas de distintas materias correspondientes al 2do semestre de docencia en informática, en donde cada uno de las notas ingresadas debe estar entre 1 y 10. Análisis.- Utilizamos 6 variables de tipo enteras y decimales realizamos los procesos e imprimimos por pantalla. DOCUMENTACIÓN #include<stdio.h> #include<conio.h> main() { int c=5,n1,n2,n3,op; float prom; clrscr(); gotoxy(27,2);printf("Facultad de Ciencias Humanas"); gotoxy(30,3);printf("Segundo Informatica"); gotoxy(8,5); printf("Modulos nota 1nota 2 nota 3promedio"); gotoxy(5,6); printf("Programacion 1"); gotoxy(5,7); printf("Fisica 2"); gotoxy(5,8); printf("Matematica Basica"); gotoxy(5,9); printf("M. de la Investigacion"); gotoxy(5,10);printf("Trabajo en Equipo"); gotoxy(5,11);printf("Realidad Nacional"); gotoxy(5,12);printf("Ntics"); do { c=c+1; do { gotoxy(39,c);printf(" "); gotoxy(39,c);scanf("%d",&n1); } while (n1>10); do { gotoxy(49,c);printf(" "); gotoxy(49,c);scanf("%d",&n2); } while (n2>10); do { gotoxy(60,c);printf(" "); gotoxy(60,c);scanf ("%d",&n3); 54 LIBRERIAS VARIABLES INICIO IMPRESION SENTECIA “IF”
  • 59.
    } while (n3>10); prom=(n1+n2+n3)/3; gotoxy(70,c);printf("%.2f",prom); gotoxy(5,15);printf("presione 1para continuar o 0 para salir");scanf("%d",&op); } while (op==1); getch(); FIN } 55
  • 60.
    CORRIDO DEL PROGRAMA ProgramaNº9  Realice un programa en C++ que me permita obtener el líquido a recibir de un empleado bajo los siguientes parámetros: El empleado percibe un salario mínimo vital el mismo que depende de su categoría, existen 3 posibles alternativas, este dato deberá ser ingresada al inicio del programa conjuntamente con el nombre del empleado:  Categoría 1 180,00  Categoría 2 250,00  Categoría 3 380,00 A este salario mínimo 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 esta condicionada. Si el empleado tiene mas 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 asociación 5. Obtenga los valores correspondientes de ingresos, egresos y total a recibir El programa se genera n veces. 56
  • 61.
    Análisis.- Utilizamos variablesde tipo enteras, decimales y de carácter, dowhile para repetir el proceso, if para que cumpla las condiciones requeridas, realizamos los proceso e imprimimos el resultado por pantalla. DOCUMENTACIÓN #include<stdio.h> LIBRERIAS #include<conio.h> main () VARIABLES { floatx=180,y=250,z=380,s,iess,i=11.5,dcto,a=2,p=1.80,ex,hex,j=4.50,k=6.20, INICIO b,in,eg,t; int c,h,op; char n[50]; do { flushall(); clrscr(); gotoxy(31,3); printf("INGRESO DE DATOS"); gotoxy(2,5); printf("Ingrese su nombre: ");flushall(); gets(n); do { gotoxy(2,8); printf("Escoja su categoria: 1, 2 o 3: "); scanf("%d",&c); } while(c>3 || c<1); gotoxy(2,11); printf("Cantidad de hijos registrados: "); scanf("%d",&h); do { gotoxy(2,14);printf("Horas extras registradas: "); scanf("%f",&hex); } while(hex<1 || hex>8); clrscr(); gotoxy(5,3); printf("********************ROL DE PAGOS********************"); gotoxy(5,5); printf("Empleado: %s",n); gotoxy(5,6); printf("Corresponde: Septiembre 2013"); gotoxy(5,7); printf("Dias laborados: 30 dias"); gotoxy(5,8); printf("**************************"); gotoxy(10,10); printf("Ingresos"); LECTURA DE gotoxy(46,10); printf("Egresos"); gotoxy(5,12); printf("Sueldo nominal "); if(c==1) { s=x; gotoxy(21,12); printf("%.2f",s); } if(c==2) { s=y; gotoxy(21,12); printf("%.2f",s); } 57
  • 62.
    if(c==3) { s=z; gotoxy(21,12); printf("%.2f",s); } iess=(s*i)/100; gotoxy(38,12); printf("Seguro:"); gotoxy(52,12); printf("%.2f",iess); dcto=(s*a)/100; gotoxy(38,13); printf("Dcto. Asoc.: "); gotoxy(52,13); printf("%.2f",dcto); ex=(hex*p); gotoxy(5,13); printf("Horas extras: "); gotoxy(21,13);printf("%.2f",ex); gotoxy(5,14); printf("Bono Familiar: "); if (h>2) { b=(h*j); gotoxy(21,14);printf("%.2f",b); } if (h<3) { b=(h*k); gotoxy(21,14);printf("%.2f",b); } in=(s+ex+b); gotoxy(5,18); printf("Total Ingresos: "); gotoxy(21,18);printf("%.2f",in); eg=(iess+dcto); gotoxy(38,18);printf("Total Egresos: "); gotoxy(52,18);printf("%.2f",eg); t=(in-eg); gotoxy(38,24);printf("TOTAL A RECIBIR: "); gotoxy(55,24);printf("%.2f",t); gotoxy(37,23);printf("*************************"); gotoxy(37,25);printf("*************************"); gotoxy(5,23); printf("presione 1 para regresar o "); gotoxy(5,24); printf("presione 0 para salir: "); scanf("%d",&op); } while (op==1); getch(); } 58 IMPRESION IMPRESION FIN
  • 63.
  • 64.
  • 65.
    Programa Nº10  Diseñeun programa que me permita imprimir un borde de pantalla. Análisis.- Utilizamos una variable de tipo entera y un ciclo for para imprimir el borde. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> main() { int i,limite,fila=6,op; fila=6; clrscr(); for (i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for (i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } getch(); } VARIABLES INICIO SENTENCIA “FOR” FIN 61
  • 66.
    CORRIDO DEL PROGRAMA ProgramaNº11  Diseñe un programa que me permita visualizar la serie de los números pares y los impares que existen hasta el número límite ingresado desde teclado. Análisis.- Utilizamos 4 variables de tipo entera, realizamos el proceso y presentamos resultados DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> main() { int i,limite,fila=6,op; do { fila=6; clrscr(); for (i=1;i<=80;i++) VARIABLES INICIO 62
  • 67.
    { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } SENTENCIA “FOR” for (i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } gotoxy(5,2);printf("ingreseel limite: ");scanf("%d",&limite); gotoxy(20,4);printf("Pares:"); for (i=2;i<=limite;i+=2) { gotoxy(23,fila);printf("%d",i); fila=fila+1; } SENTENCIA “FOR” fila=6; gotoxy(42,4);printf("Impares:"); for (i=1;i<=limite;i+=2) { gotoxy(46,fila);printf("%d",i); fila=fila+1; } gotoxy(60,21);printf("presione:"); gotoxy(60,22);printf("1 para continuar"); gotoxy(60,23);printf("0 para salir: "); scanf("%d",&op); } while(op==1); getch(); } FIN 63
  • 68.
  • 69.
    Programa Nº612  Realizarun programa y visualizar los números primos. Análisis.- Activamos la librerías, utilizamos variables de tipo enteras, dowhile para que cumpla la condición requerida, realizamos el proceso y presentamos resultados DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> #include<string.h> main() { int i, j, fla=7, lim, cnt=0, resul, op; do { fla=7; clrscr(); gotoxy(35,3);printf("NUMEROS PRIMOS"); for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } gotoxy(5,8);printf("ingrese limite: ");scanf("%d",&lim); for(i=1;i<=lim;i++) { cnt=0; for(j=1;j<=i;j++) { resul=i%j; if(resul==0) { cnt=cnt+1; } } if(cnt==2) { gotoxy(40,fla);printf("%d",i); fla=fla+1; } } 65 VARIABLES INICIO SENTENCIA “FOR” SENTENCIA “FOR”
  • 70.
    CORRIDO DEL PROGRAMA ProgramaNº13  Diseñe un programa que me permita visualizar la factorial de un número ingresado desde teclado. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for y realizamos los proceso y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> main() { int i,j,m,l,f=1,op; do { clrscr(); f=1; //borde de pantalla m=10; for (i=1;i<=80;i++) { gotoxy(i,1); printf("*"); gotoxy(i,24);printf("*"); } VARIABLES INICIO SENTENCIA “FOR” 66
  • 71.
    for (i=1;i<=24;i++) { gotoxy(1,i); printf("*"); gotoxy(80,i);printf("*"); } gotoxy(31,3);printf("FACTORIALES"); gotoxy(15,7);printf("ingreseel limite: ");scanf("%d",&l); for (j=1;j<=l;j++) { f=f*j; gotoxy(20,m);printf("El factorial de: %d = %d",j,f); m=m+1; } gotoxy(15,22);printf("presione 1 para continuar o 0 para salir: ");scanf("%d",&op); } while (op==1); getch(); } 67 LECTURA DE FIN
  • 72.
    CORRIDO DEL PROGRAMA ProgramaNº14  Diseñe un programa que me permita ejercer la tabla de multiplicación de cualquier factor imprimido desde teclado y por cualquier limite impreso desde teclado, el programa se genera n veces, diseñe el borde de la pantalla. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> main () { int fac,lim,i,n,m,j,op ; do { clrscr(); //borde de pantalla m=9; for (i=1;i<=80;i++) { gotoxy(i,1); printf("*"); gotoxy(i,24);printf("*"); } for (i=1;i<=24;i++) VARIABLES INICIO SENTENCIA “FOR” 68
  • 73.
    { gotoxy(1,i); printf("*"); gotoxy(80,i);printf("*"); } //tabla demultiplicar gotoxy(31,3); printf("TABLAS DE MULTIPLICAR"); gotoxy(10,5); printf("Factor: ");scanf("%d",&fac); gotoxy(10,7); printf("Limite: ");scanf("%d",&lim); for(j=1;j<=lim;j++) { n=fac*j; gotoxy(19,m); printf("%d",fac); gotoxy(21,m); printf("*"); gotoxy(23,m); printf("%d",j); gotoxy(25,m); printf("="); gotoxy(27,m); printf("%d",n); m=m+1; } gotoxy(8,22); printf("presione 1 para regresar o 0 para salir: ");scanf("%d",&op); } while (op==1); getch(); } 69 FIN
  • 74.
    CORRIDO DEL PROGRAMA ProgramaNº15  Diseñe un programa en c++ que me permita visualizar los números primos con repetición y el borde. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<conio.h> #include<stdio.h> main() { int i=0,j=0,lt,c,res=0,op=1,nc=0; do { clrscr(); for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(79,i);printf("*"); } for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); VARIABLES INICIO SENTENCIA “FOR” 70
  • 75.
    } gotoxy(29,2);printf("NUMEROS PRIMOS"); gotoxy(6,4);printf("INGRESE ELLIMITE : ");scanf("%d",&lt); gotoxy(6,6);printf("1"); c=2; for(i=2;i<=lt;i++) { for(j=1;j<=c;j++) { if(i%j==0) { nc=nc+1; } } if(nc==2) { printf("%6d",i); } nc=0; c=c+1; } gotoxy(2,23),printf("REPETIR 1 Y 0 PARA SALIR : ");scanf("%d",&op); } while(op==1); getch(); FIN } 71
  • 76.
    CORRIDO DEL PROGRAMA ProgramaNº16  Diseñe un programa que me permita generar cualquier seria de números. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los proceso y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<conio.h> #include<stdio.h> void main() { int limite,i,fla,op; do { clrscr(); for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) VARIABLES INICIO SENTENCIA “FOR” 72
  • 77.
  • 78.
    CORRIDO DEL PROGRAMA ProgramaNº17  Diseñe un programa que me permita generar una serie de números, en donde el numerados es cualquier factor ingresado desde teclado, y el numerador es la serie de los números impares. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> void main () { int i,l,j,c,d,s,p,op,fa; do { clrscr(); for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) VARIABLES INICIO SENTENCIA “FOR” 74
  • 79.
    { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } gotoxy(16,2);printf("SERIE DE NUMEROSNUMERADOR CUALQUIER,DENOMINADOR IMPAR"); gotoxy(10,3);printf("Ingrse el limite: ");scanf("%d",&l); gotoxy(10,4);printf("ingrese el factor:");scanf("%d",&fa); c=0; d=1; for(i=1;i<=l;i++) { c=c+3; gotoxy(5,6+i);printf("%d",c); d=d+2; gotoxy(13,6+i);printf("%d",d); gotoxy(9,6+i);printf("/"); } gotoxy(10,20);printf("Desea continuar 1 caso contario 0: ");scanf("%d",&op); }while(op==1); getch(); } 75 LECTURA DE FIN
  • 80.
    CORRIDO DEL PROGRAMA ProgramaNº18  Realice un programa que me permita general la siguiente serie de datos: N= 5 Factor impar como numerador Factorial como denominador Análisis.- Utilizamos variables de tipo enteras y decimales, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<conio.h> #include<stdio.h> void main() { int s,f,i,d,j,op; float factorial; do { clrscr(); for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); VARIABLES INICIO SENTENCIA “FOR” 76
  • 81.
    } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } gotoxy(15,2);printf("SERIE DE NUMEROSCON NUMERADOR IMPAR E FACTORIAL DENOMINADOR"); gotoxy(10,3);printf("Ingrse el limite: ");scanf("%d",&s); do { gotoxy(32,4);printf(" "); gotoxy(10,4);printf("ingrese el factor:");scanf("%d",&f); } while(f%2==0); factorial=1; for(i=1;i<=s;i++) { factorial=factorial*i; gotoxy(5,6+i);printf("%d",f); f=f+2; gotoxy(13,6+i);printf("%4.0f",factorial); gotoxy(9,6+i);printf("/"); } gotoxy(10,20);printf("Desea continuar 1 caso contario 0: ");scanf("%d",&op); }while(op==1); getch(); } 77 IMPRESION FIN
  • 82.
    CORRIDO DEL PROGRAMA ProgramaNº19ç  Generar n elementos de la siguiente serie, cualquier factor ingresando desde teclado como numerador, el denominador números pares. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN #include<stdio.h> #include<conio.h> void main () { int i,l,j,c,d,s,p,op,fa; do { clrscr(); for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); LIBRERIAS VARIABLES INICIO SENTENCIA “FOR” 78
  • 83.
    } gotoxy(16,2);printf("SERIE DE NUMEROSNUMERADOR CUALQUIER,DENOMINADOR PAR"); gotoxy(10,3);printf("Ingrse el limite: ");scanf("%d",&l); gotoxy(10,4);printf("ingrese el factor:");scanf("%d",&fa); c=0; d=0; for(i=1;i<=l;i++) { c=c+3; gotoxy(5,6+i);printf("%d",c); d=d+2; gotoxy(13,6+i);printf("%d",d); gotoxy(9,6+i);printf("/"); } gotoxy(10,20);printf("Desea continuar 1 caso contario 0: ");scanf("%d",&op); }while(op==1); getch(); } 79 IMPRESION FIN
  • 84.
    CORRIDO DEL PROGRAMA ProgramaNº20  Genere una serie de datos que lleve por numerador el factorial y por denominador la serie de Fibonacci Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<conio.h> #include<stdio.h> main() { int i, limit, fibon=0, colum=5, b=1, c=0, fac=1, op; do { fibon=0, colum=5, b=1, c=0, fac=1; clrscr(); for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) { 80 VARIABLES INICIO SENTENCIA “FOR”
  • 85.
    gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } gotoxy(17,3);printf("SERIE NUMERADOR FACTORIAL YDENOMINADOR FIBONACCI"); gotoxy(4,5);printf("numero a visualizar: ");scanf("%d",&limit); LECTURA DE for(i=1;i<=limit;i++) { gotoxy(colum,9);printf("%d",fibon); fibon=b+c; b=c; OPERACIONES c=fibon; gotoxy(colum,8);printf("-"); gotoxy(colum,7);printf("%d",fac); fac=fac*i; colum=colum+5; } gotoxy(3,22);printf("PRESIONE 1 PARA REPETIR LA SERIE O 0 PARA LECTURA DE FINALIZAR>> ");scanf("%d",&op); } while(op==1); getch(); } FIN 81
  • 86.
    CORRIDO DEL PROGRAMA ProgramaNº21  Genere la siguiente serie de datos primos en el numerador e impares en el denominador. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, sentencias if realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> #include<string.h> main() { int i, j, np, cot=0, c=5, resul, op, colum=15, imp=1, aux; do { imp=1; colum=15; c=10; clrscr(); VARIABLES 82 INICIO
  • 87.
    gotoxy(16,3);printf("SERIE NUMERADOR PRIMOSDENOMINADOR IMPARES"); for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); SENTENCIA “FOR” gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } gotoxy(3,5);printf("Limite: ");scanf("%d",&np); gotoxy(10,7);printf("1"); gotoxy(8,6);printf("Serie: "); aux=0; for(i=1;i<=(2*np);i++) { if(aux==np) {break; } SENTENCIA “FOR” cot=0; for(j=1;j<=i;j++) { resul=i%j; if(resul==0) { cot=cot+1; } } if(cot==2) { gotoxy(colum,7);printf("%d",i); aux=aux+1; gotoxy(colum,8);printf("-"); IMPRESION colum=colum+5; gotoxy(c,9);printf("%d",imp); imp=imp+2; c=c+5; } } gotoxy(3,23);printf("PRESIONE 1 PARA REPETIR EL PROCESO O 0 PARA FINALIZAR: ");scanf("%d",&op); } while(op==1); getch(); FIN } 83
  • 88.
  • 89.
    Programa Nº22  Realiceun menú que me permita realizar las conversiones básicas de metro, kilometro, hectómetro y decímetro. Análisis.- Activamos las librerías, utilizamos variables de tipo enteras, y decimales, do-while para que cumpla la condición requerida, sentencias for, un swich para las opciones, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<conio.h> #include<stdio.h> VARIABLES #include<stdlib.h> INICIO void borde() { int i; clrscr(); for(i=1;i<=80;i++) { gotoxy(i,1);printf("±"); gotoxy(i,24);printf("±"); SENTENCIA “FOR” } for(i=1;i<=24;i++) { gotoxy(1,i);printf("±"); gotoxy(80,i);printf("±"); } } void main() { int op,col=8; float km,nu,dam,hm,m; clrscr(); do { borde(); gotoxy(32,3);printf("CONVERSIONES BASICAS"); gotoxy(32,2);printf("////////////////////"); IMPRESION gotoxy(32,4);printf("////////////////////"); gotoxy(5,6);printf("1.- De Metros a Km - Hm - Dam"); gotoxy(5,8);printf("2.- De Kilometros a M - Hm - Dam"); gotoxy(5,10);printf("3.- De Hectometros a M - Km - Dam"); gotoxy(5,12);printf("4.- De Decametros a M - Km - Hm"); gotoxy(5,14);printf("5.- Salir"); gotoxy(5,22);printf("Que opcion desea realizar: ");scanf("%d",&op); switch(op) { case 1: clrscr(); 85
  • 90.
    borde(); gotoxy(33,3);printf("De Metros aKm - Hm - Dam"); gotoxy(5,5);printf("Ingrece la cantidad: ");scanf("%f",&nu); km=nu*0.001; hm=nu*0.01; dam=nu*0.1; gotoxy(col,8);printf("Km = %f",km); gotoxy(col,10);printf("Hm = %f",hm); gotoxy(col,12);printf("Dam = %f",dam); break; case 2: clrscr(); borde(); gotoxy(33,3);printf("De Kilometros a M - Hm - Dam"); gotoxy(5,5);printf("Ingrece la cantidad: ");scanf("%f",&nu); m=nu*1000; hm=nu*100; dam=nu*10; gotoxy(col,8);printf("M = %f",m); gotoxy(col,12);printf("Hm = %f",hm); gotoxy(col,10);printf("Dam = %f",dam); break; case 3: clrscr(); borde(); gotoxy(33,3);printf("De Hectometros a M - Km - Dam"); gotoxy(5,5);printf("Ingrece la cantidad: ");scanf("%f",&nu); km=nu*0.1; m=nu*100; dam=nu*10; gotoxy(col,12);printf("Km = %f",km); gotoxy(col,8);printf("M = %f",m); gotoxy(col,10);printf("Dam = %f",dam); break; case 4: clrscr(); borde(); gotoxy(33,3);printf("De Metros a M - Km - Hm"); gotoxy(5,5);printf("Ingrece la cantidad: ");scanf("%f",&nu); km=nu*0.001; hm=nu*0.01; m=nu*10; gotoxy(col,12);printf("Km = %f",km); gotoxy(col,10);printf("Hm = %f",hm); gotoxy(col,8);printf("M = %f",m); break; case 5: exit(0); break; } 86 IMPRESION IMPRESION IMPRESION FIN
  • 91.
    gotoxy(3,23);printf("1 PARA VOLVERAL MENU DE DATOS 0 PARA FINALIZAR: ");scanf("%d",&op); } while(op==1); getch(); } 87 FIN
  • 92.
    CORRIDO DEL PROGRAMA ProgramaNº23  Diseñe un programa que me permita realizar un borde utilizaciones funciones. Análisis.- Utilizamos una variable de tipo enteras, sentencias for para que cumpla la condición requerida, llamamos a la función borde y presentamos resultados. 88
  • 93.
  • 94.
    CORRIDO DEL PROGRAMA ProgramaNº24 Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> int numero,i,op; void borde() { for(i=1;i<=80;i++) { gotoxy(i,1);printf("• "); gotoxy(i,24);printf("• "); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("• "); gotoxy(80,i);printf("• "); } } void numeros(int num) { for(i=1;i<=numero;i++) VARIABLES INICIO SENTENCIA “FOR” 90
  • 95.
  • 96.
    CORRIDO DEL PROGRAMA ProgramaNº25  Diseñe un programa que me permita ingresar tres valores enteros desde teclado entre 4 y 64 y presentarlos en forma ordenada ascendentemente. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> #include<stdlib.h> int i,a,b,c; void borde () { VARIABLES INICIO 92
  • 97.
    for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); SENTENCIA “FOR” gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } } void nun( ) { if(a>b && a>c) { gotoxy(16,14);printf("%d",a); } else { if(b<a && b>c) { gotoxy(16,15);printf("%d",b); } else FUNSION { gotoxy(16,16);printf("%d",c); } if(c<a && c>b) { gotoxy(16,17);printf("%d",c); } else { gotoxy(16,18);printf("%d",b); } } } void main() { clrscr(); borde (); gotoxy(30,3);printf("ASCENDENTE"); do { gotoxy(37,5);printf(" "); gotoxy(12,5);printf("Ingrese el primer numero:");scanf("%d",&a); }while(a<3||a>65); do { gotoxy(37,7);printf(" "); 93
  • 98.
    gotoxy(12,7);printf("Ingrese el segundonumero:");scanf("%d",&b); }while(b<3||b>65); do { gotoxy(37,9);printf(" "); gotoxy(12,9);printf("Ingrese el tercer numero:");scanf("%d",&c); }while(c<3||c>65); nun (); getch(); FIN } 94
  • 99.
  • 100.
    33.-Diseñe un programautilizando funciones que me permita ingresar 3 valores enteros desde teclado entre 4 y 64 y presentarlos en forma ordenada ascendentemente. ANALISIS Para este programa se necesitan varias funciones de condición if para hacer la comparación y así poder imprimir los números en forma ascendente y para validar los números también otros if para que el número ingresado este el rango que se pedía en el programa DOCUMENTACION #include<stdio.h> LIBRERIAS #include<conio.h> int i,a,b,c,op; Declaración de variables Inicio de la función borde void borde() { for(i=1;i<=80;i++) { gotoxy(i,1);printf("±"); gotoxy(i,24);printf("±"); } Impresión del margen for(i=1;i<=24;i++) { gotoxy(1,i);printf("±"); gotoxy(80,i);printf("±"); } } void numero() Inicio de la función void main { do Inicio del do { gotoxy(24,4);printf(" "); Ingreso el primer numero gotoxy(15,4);printf("Numero 1; ");scanf("%d",&a); } while(a>64 || a<4); Si ese número cumple con la condición empleada pide el siguiente número do { gotoxy(24,5);printf(" Inicio del do "); Ingreso el segundo numero 96
  • 101.
    gotoxy(15,5);printf("Numero 2: ");scanf("%d",&b); } Siese número cumple con la condición while(b>64 || b<4); empleada pide el siguiente numero do Inicio del do { gotoxy(24,6);printf(" "); gotoxy(15,6);printf("Numero 3: ");scanf("%d",&c); Ingreso el tercer numero }while(c>64 || c<4); } void orden() Inicio de la función void orden { 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 if(b<=a && b<=c) los números 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); } 97
  • 102.
    } gotoxy(15,7);printf("El orden es:"); } Iniciode la función principal void main() { do { Borrar pantalla clrscr(); borde(); Llamar al borde Llamar a la función numero Llamar a la función orden numero(); orden(); gotoxy(15,22);printf("Desea salir 1/0: ");scanf("%d",&op); } while(op==1); Si la opción ingresada por el usuario es igual a 1 el proceso se repetirá getch(); } Fin del programa CORRIDO DEL PROGRAMA 98
  • 103.
    34.- Diseñe unprograma utilizando funciones que me permita generar y visualizar los números perfectos. ANALISIS    En este programa utilizamos la librería math porque utilizamos la función pow Utilizamos un do –while para que el usuario ingrese otro limite o quiera salir del programa Aquí también empleamos la utilización de las funciones DOCUMENTACION #include<stdio.h> LIBRERIAS #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++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } } void perfecto(int l) { r=pow(dos,ex); s=pow(dos,ex2); v=r*(s-1); gotoxy(7,8);printf("%d",v); for(i=1;i<=l-1;i++) { a=pow(dos,expo2); Inicio de la función borde Impresión del margen Inicio de la función void perfecto Operaciones para sacar los números perfectos Operaciones para sacar los números perfectos 99 Declaración de variables
  • 104.
    b=pow(dos,expo3); expo2=expo2+2; expo3=expo3+2; c=a*(b-1); gotoxy(7,f);printf("%d",c); f=f+1; } }//cierre del void Impresiónde los números perfectos Inicio de la función principal void main() { do { f=9,dos=2,ex=1,ex2=2,expo2=2,expo3=3,f=9; Declaración de variables clrscr(); Borrar pantalla 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 función perfecto Impresión del titulo Ingreso del limite perfecto(l1); gotoxy(50,22);printf(" "); gotoxy(4,22);printf("PRESIONE 1 PARA VOLVER AL MENU O 0 PARA SALIR: ");scanf("%d",&op); } while(op==1); Si la opción ingresada por el usuario es igual a 1 el proceso se repetirá getch(); } Fin del programa CORRIDO DEL PROGRAMA 100
  • 105.
    35.- Diseñe unprograma utilizando funciones que me permita resolver un sistema de ecuación de 2° grado. ANÁLISIS Partiremos escribiendo la fórmula para tener base de que nomás se va a utilizar. La fórmula genera dos respuestas: Una con el signo más (+) y otra con el signo menos (−) antes de la raíz. Solucionar una ecuación de segundo grado se limita, entonces, a identificar las letras a, b y c y sustituir sus valores en la fórmula. La fórmula general para resolver una ecuación de segundo grado sirve para resolver cualquier ecuación de segundo grado, sea completa o incompleta, y obtener buenos resultados tiene que ver con las técnicas de factorización. CODIFICACIÓN #include <stdio.h> #include <stdlib.h> #include <conio.h> #include <math.h> int i,j,op; void borde() { textcolor(BLUE); for(i=1;i<=80;i++) { gotoxy(i,1);cprintf("*"); gotoxy(i,24);cprintf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);cprintf("*"); gotoxy(80,i);cprintf("*"); } } void seg () { float a, b, c; float x1, x2; float x1real, x2real; Activation de Liberia // declaración de variables globales función del borde // impression de * // fin del ciclo for // fin de la function borde // function para la ecuacion // inicio de la function /* complejas 101 */
  • 106.
    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 GRADOn"); gotoxy(2,4);printf("============================================== ================n"); gotoxy(10,5);printf("El programa soluciona la ecuación de segundo gradon"); gotoxy(10,6);printf(" 2 n"); gotoxy(10,7);printf("ax + bx + c = 0 n"); /* Petición 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); /* Cálculos y resultados */ discriminante = b*b - 4*a*c; // calculo de discriminate printf("n La ecuacionn"); printf(" %14dn", 2); printf(" %12gx + %gx + %g = 0n", a, b, c); // impresiones printf(" tiene por soluciones "); if (discriminante == 0) // sentencia si dis es = a 0 { // inicio de if printf(" una raiz real doblen"); // impresión x1 = x2 = -b / (2*a); // calculo printf(" x1 = %.2fn", x1); printf(" x2 = %.2fn", x2); // impresión en pantalla } // fin de if else if (discriminante > 0) //si dis es mayor a cero { // cálculos printf(" dos raices realesn"); x1 = (-b + sqrt(discriminante)) / (2*a); x2 = (-b - sqrt(discriminante)) / (2*a); // impresiones printf("x1 = %.2fn", x1); printf("x2 = %.2fn", x2); } Else // caso contrario { //impresión en pantalla printf("dos raíces complejas conjugadasn"); //cálculos x1real = x2real = -b / (2*a); x1imag = sqrt(-discriminante) / (2*a); x2imag = -sqrt(-discriminante) / (2*a); // impresiones 102
  • 107.
    } } void main () { Do { printf("x1= ( %.2f, %.2fi)n", x1real, x1imag); printf("x2 = ( %.2f, %.2fi)n", x2real, x2imag); //fin del ese // fin de la función // inicio del programa // llave de inicio //ciclo do // llave de inicio de do borde (); // funcion borde seg (); // funcion seg gotoxy(22,22);printf("desea continuar: ");scanf("%d",&op); // impresión en pantalla y lectura } while(op==1); getch(); //pausa } // fin del programa. Corrido del Programa 103
  • 108.
    38.- Diseñe unprograma utilizando vectores y funciones que me permita ingresar datos a un vector y presentarlos en otro vector ANÁLISIS Primero ingresamos las librerías que vamos a utilizar en este programa en este caso son las dos principales la STDIO.H Y LA CONIO.H, después como es un programa con funciones declaramos la variable que vamos a utilizar globalmente. Después ingresamos una función 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 demás variables a realizar en el programa (int vector1[10],fila,op,lim;), después ponemos un do-while para que se repita el programa n veces y llamamos las funciones realizadas y realizamos el ingreso del límite para que podaos ingresar datos a una función y que luego se visualice. DOCUMENTACIÓN #include<stdio.h> Librerías que vamos a utilizar en el programa #include<conio.h> int i; Declaramos la variable global void borde() { for(i=1;i<=80;i++) { gotoxy(i,1); printf("*"); gotoxy(i,24); printf("*"); } Realizamos la función para que se pueda realizar un borde en nuestro programa for(i=1;i<=24;i++) { gotoxy(1,i); printf("*"); gotoxy(80,i); printf("*"); } } void main() { Realizamos el programa principal y declaramos la variables que vamos a utilizar en el programa principal 104
  • 109.
    int vector1[10],fila,op,lim; do { clrscr(); borde(); gotoxy(25,3); printf("**VISUALIZARDATOS VECTOR**"); Aquí damos un limite al vector para poder dar datos numéricos a un limita vector gotoxy(10,5); printf("INGRESE EL LIMITE==>"); scanf("%d",&lim); Ingresamos el limite fila=6; for(i=1;i<=lim;i++) { do { gotoxy(20,fila); printf(" "); Ingresamos los números para que se llene el vector previamente dado un limite gotoxy(20,fila); scanf("%d",&vector1[i]); } while(vector1[i]<3 || vector1[i]>23); Damos o validamos los datos que estén entre 3 y 23 fila=fila+1; } fila=6; for(i=1;i<=lim;i++) Aquí se visualiza el vector que ingresamos en otra posición { gotoxy(40,fila); printf("%d",vector1[i]); fila=fila+1; } gotoxy(10,20); printf("PRESIONE 1 PARA REPETIR EL PROGRAMA CASO CONTRARIO 0==>"); scanf("%d",&op); Ingresamos otra opción para ver si se repite el programa n veces } while(op); getch(); Visualiza la opción y da por terminado el programa } 105
  • 110.
  • 111.
  • 112.
    41.- Diseñe unprograma utilizando vectores y un menú de opciones que me permita realizar las 4 operaciones básicas, estas son: suma, resta, multiplicación y división. ANALISIS En este programa se realizan las operaciones básicas que son la suma, resta, multiplicación y división 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 división en donde el valor del vector1 debe ser mayor al valor del vector2 si no se cumple la condición no se realiza las operaciones y se imprime un mensaje. DOCUMENTACION #include<stdio.h> #include<conio.h> Ingreso las librerías #include<stdlib.h> int multivec[15],opc,divisionvec[15], restavec[15],i,op,col,fila,vector1[15],vector2[15], Declaración de variables sumavec[15],limite1; void borde() Función borde { for(i=1;i<=80;i++) { Este proceso es para realizar el borde gotoxy(i,1); printf("*"); gotoxy(i,24); printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i); printf("*"); gotoxy(80,i); printf("*"); } } void ingreso(int limite1) Función para ingresar los valores de los vectores 108
  • 113.
    { col=12; fila=8; Ingresamos la posiciónen la cual se va a visualizar los vectores for(i=1;i<=limite1;i++) { Utilizamos el for para poder ingresar los valores del vector1 y vector2 al final vamos sumando fila para q vayan colocándose en las posiciones correctas, cerramos la laves del for y la llaves de la función ingreso. gotoxy(col,fila); scanf("%d",&vector1[i]); gotoxy(col+10, fila); scanf("%d",&vector2[i]); fila=fila+1; } } void suma(int limite1) Función 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. for(i=1;i<=limite1;i++) { sumavec[i]=vector1[i]+vector2[i]; gotoxy(40,fila); printf("%d",sumavec[i]); fila=fila+1; } Utilizamos el for para poder ingresar los valores del vector1 y vector2, realizamos la operación en donde se suman los dos vectores e imprimimos el resultado, vamos sumando fila para las correctas posiciones cerramos el for y la función suma. } void resta(int limite1) { fila=8; Función para realizar la resta Abrimos con una llave Ingresamos el valor de la fila en la que va a empezar a visualizarse los datos del vector. 109
  • 114.
    for(i=1;i<=limite1;i++) { if(vector1[i]>=vector2[i]) { restavec[i]=vector1[i]-vector2[i]; gotoxy(40,fila); printf("%d",restavec[i]); } else { gotoxy(40,fila); printf("NOSE PUEDE CALCULAR"); } fila=fila+1; } } Utilizamos el for para poder 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 condición se cumple realizamos la operación en donde se resta los valores del vector que sea mayor e imprimimos el resultado, cerramos el if y si no se cumple la condición escribimos un mensaje y no se realiza la operación, cerramos la llaves y vamos sumando fila para las correctas posiciones cerramos el for y la función void multi(int limite1) Función para realizar la multiplicación { Abrimos con una llave fila=8; Ingresamos el valor de la fila en la que va a empezar a visualizarse los datos del vector. for(i=1;i<=limite1;i++) Utilizamos el for para poder ingresar los valores del vector1 y vector2, realizamos la operación en donde se mulitiplican los dos vectores e imprimimos el resultado, vamos sumando fila para las correctas posiciones cerramos el for y la función multi. { multivec[i]=vector1[i]*vector2[i]; gotoxy(40,fila); printf("%d",multivec[i]); fila=fila+1; } } void division(limite1) Función para realizar la división. { Abrimos con una llave fila=8; Ingresamos el valor de la fila en la que va a empezar a visualizarse los datos del vector. 110
  • 115.
    for(i=1;i<=limite1;i++) { if(vector1[i]>=vector2[i]) { divisionvec[i]=vector1[i]/vector2[i]; gotoxy(40,fila); printf("%d",divisionvec[i]); } else { gotoxy(40,fila); printf("NO SEPUEDE CALCULAR"); } fila=fila+1; } } void main() { Utilizamos el for para poder 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 condición se cumple realizamos la operación en donde se dividen los valores del vector que sea mayor e imprimimos el resultado, cerramos el if y si no se cumple la condición escribimos un mensaje y no se realiza la operación, cerramos la llaves y vamos sumando fila para las correctas posiciones cerramos el for y la función división. Función principal del programa. Abrimos con una llave do { clrscr(); Utilizamos el ciclo do while para que el proceso se repita tantas veces desee el usuario Limpia la pantalla. borde(); Llama a la función borde. gotoxy(15,3); printf("**OPERACIONES CON VECTORES Y FUNCIONES**"); gotoxy(10,5); printf("1.-SUMA"); Diseño de pantalla. gotoxy(10,7); printf("2.-RESTA"); gotoxy(10,9); printf("3.-MULTIPLICACION"); gotoxy(10,11); printf("4.-DIVISION"); gotoxy(10,13); printf("QUE OPCION DESEA==>"); 111
  • 116.
    scanf("%d",&op); switch(op) { case 1: do Utilizamos lasentencia switch para el menú de opciones. { clrscr(); borde(); gotoxy(30,3);printf("1.-SUMA"); gotoxy(11,7); printf("VECTOR 1"); gotoxy(21,7); printf("VECTOR 2"); gotoxy(40,7); printf("SUMA VECTOR"); gotoxy(10,5); printf("INGRESE LIMITE==>"); scanf("%d",&limite1); 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 { 112
  • 117.
    clrscr(); borde(); gotoxy(30,3); printf("2.-RESTA"); gotoxy(11,7); printf("VECTOR1"); gotoxy(21,7); printf("VECTOR 2"); gotoxy(40,7); printf("RESTA VECTOR"); gotoxy(10,5); printf("INGRESE LIMITE==>"); scanf("%d",&limite1); ingreso(limite1); resta(limite1); Diseño de la segunda opción 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 cerramos con un break. gotoxy(10,23); printf("SI DESEA REPETIR EL PROCESO PRESIONE 1 CASO CONTRARIO 0==>"); scanf("%d",&opc); } while(opc==1); break; case 3: do { clrscr(); borde(); gotoxy(30,3); printf("3.-MULTIPLICACION"); gotoxy(11,7); printf("VECTOR 1"); gotoxy(21,7); printf("VECTOR 2"); Diseño de la tercera opción 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 cerramos con un break. gotoxy(40,7); printf("MULTIPLICACION VECTOR"); gotoxy(10,5); printf("INGRESE LIMITE==>"); scanf("%d",&limite1); ingreso(limite1); multi(limite1); gotoxy(10,23); printf("SI DESEA REPETIR EL PROCESO PRESIONE 1 CASO CONTRARIO 0==>"); 113
  • 118.
    scanf("%d",&opc); } while(opc==1); break; do { case 4: clrscr(); borde(); gotoxy(30,3); printf("4.-DIVISION"); gotoxy(11,7);printf("VECTOR 1"); gotoxy(21,7); printf("VECTOR 2"); gotoxy(40,7); printf("DIVISION VECTOR"); gotoxy(10,5); printf("INGRESE LIMITE==>"); scanf("%d",&limite1); ingreso(limite1); Diseño de la cuarta opción 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 cerramos con un break. 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 función 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 114
  • 119.
  • 120.
  • 121.
    42.- Diseñe unprograma utilizando funciones que me permita ingresar n números en un vector entre 6 y 26, recorra el vector y encuentre todas las posiciones pares y asígnelas a un nuevo vector, recorra el vector original y encuentre todas las posiciones impares del vector y asígnelos a un nuevo vector, visualice el vector de entrada y los vectores resultantes. ANALISIS Nos pedirá ingresar un límite 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í también nos genera un borde como diseño del programa, y como final tenemos ingresar uno para continuar utilizando nuestro programa o 0 para salir del mismo. DOCUMENTACION #include<conio.h> #include<stdio.h> Activación de librería esto habilita procesos para el programa #include<stdlib.h> int i, j=1, f, vect[10], vectpar[10], vectimp[10], op, l; void bdob() Declaración de variables que se utilizaran en el programa { int i; Función borde clrscr(); gotoxy(1,1);printf("*"); gotoxy(80,1);printf("*"); Generación del borde utilizando posiciones e imprimiendo el borde que va a ir en pantalla for(i=2;i<=79;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } gotoxy(1,24);printf("*"); gotoxy(80,24);printf("*"); for(i=2;i<=23;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } } 117
  • 122.
    void par() { j=1; for(i=1;i<=l;i++) { if(i%2==0) { vectpar[j]=vect[i]; j=j+1; } Proceso decomparación si la posición es par y se almacenara en un nuevo vector y se imprimirá en pantalla utilizaremos el gotoxy para posiciones en pantalla } f=10; for(i=1;i<j;i++) { gotoxy(39,f);printf("%d",vectpar[i]); f=f+1; } } void impar() { Función para ver si la posición es impar j=1; for(i=1;i<=l;i++) { Comparación si la función es impar if(i%2==1) { vectimp[j]=vect[i]; Almacenamiento en un nuevo vector j=j+1; } } f=10; 118
  • 123.
    for(i=1;i<j;i++) { gotoxy(60,f);printf("%d",vectimp[i]); f=f+1; Impresión de datosde las posiciones impares } } void main() Programa principal { do { flushall(); Do while este nos ayuda a utilizar el programa cuantas veces deseemos f=10; clrscr(); bdob(); Limpia pantalla Llama a la función del borde gotoxy(36,3);printf("VECTORES"); gotoxy(5,5);printf("Ingrese el limite>> ");scanf("%d",&l); Pide ingresar un limite de generación de datos gotoxy(15,8);printf("VECTOR 1"); 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); Ingreso de datos del vector do { gotoxy(20,f);printf(" "); gotoxy(20,f);scanf("%d",&vect[i]); } while(vect[i]<6 || vect[i]>26); f=f+1; Validación de los datos, estos deben ser mayor que seis y menor que veinte y seis } par(); Llama a la función par Llama a la función impar 119
  • 124.
    impar(); gotoxy(3,22);printf("PRESIONE ");scanf("%d",&op); 1 PARA CONTINUAR O } while(op==1); Cierre del dowhile getch(); } Cierre o fin del programa CORRIDO DEL PROGRAMA 120 0CASO CONTRARIO::>
  • 125.
    43.-Diseñe un programautilizando 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. DOCUMENTACION #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() { ELABORACION DE UN BORDE PARA DISEÑO DE PANTALLA UTILIZANDO POSICIONES. for(i=1;i<=79;i++) { gotoxy(80,1);printf("*"); gotoxy(1,1);printf("*"); gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for(i=2;i<=23;i++) { gotoxy(1,24);printf("*"); gotoxy(80,24);printf("*"); gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } } void serie(int m) FUNCION SERIE DONDE GENERARA EL FIBONACI Y EL FACTOREAL { a=1; IGUALACION DE VARIABLE. DESDE QUE NUMERO DESEAMOS QUE EMPIESE b=0; 121
  • 126.
    f=1; gotoxy(9,6);printf("FIBONACI FACTOREAL"); for(i=1;i<=m;i++) IMPRIMIRA LOS MENSAJESQUE DESEEMOS { REALIZARA OPERACIONES PARA CALCULAR FIBONACI Y FACTOREAL f=f*i; c=a+b; a=b; b=c; gotoxy(15,8+i);printf("%d",c); IMPRIMIRA LOS RESULTADOS DE FIBONACI Y FACTOREAL gotoxy(25,8+i);printf("%0.0f",f); COMPRUEBA SI LA POSICION ES PAR O IMPAR if(i%2==0) { vect[i]=c; } 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; } } PROGRAMA PRINCIPAL void main() { do CICLO DO WHILE ESTE AYUDARA A REGRESAR AL PROGRAMA CUANTAS VECES { 122
  • 127.
    clrscr(); borde(); gotoxy(30,2);printf("... SERIE CONVECTORES ..."); 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); CIERRE O FIN DEL PROGRAMA getch(); } CORIDO DEL PROGRAMA 123
  • 128.
    44.- Diseñe unprograma 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. ANÁLISIS     Primero ingresamos las librerías las cuales son muy importantes. Luego realizamos un for donde nos permite hacer el borde de nuestro programa. Realizamos una función en la cual hacemos el proceso de los números pares e impares con vectores. Para finalizar abrimos la función principal donde llamamos a las demás funciones para que se realice el proceso y asi finalizamos nuestro programa, y obtenemos lo que deseamos. DOCUMNTACION #include<conio.h> Librerías 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); gotoxy(i,1);cprintf("Í"); Nuestro Borde acompañado de una Función. gotoxy(i,24);cprintf("Í"); } gotoxy(1,24);cprintf("È");gotoxy(80,24);cprintf("¼"); for(i=2;i<=23;i++) { 124
  • 129.
    textcolor(i); gotoxy(1,i);cprintf("º");gotoxy(80,i);cprintf("º"); } } void busq(int l) Funcióndonde realizaremos el proceso del ejercicio { Abrimos llave para nuestra Función. f=9; Igualación de variables for(i=1;i<=l;i++) Este for nos indica el límite y abrimos la llave del primer for. { if(vect[i]%2==0) Dentro del for realizamos un if donde nos indica si la división es igual a cero es para el número par, e imprimimos en un nuevo vector el resultado en caso que sea número par. { gotoxy(34,f);printf("%d",vect[i]); f=f+1; } } f=9; Cerramos la llave del primer for Igualación de la variable for(i=1;i<=l;i++) { Este es un segundo for nos indica el límite y abrimos llave para inicializar el for. if(vect[i]%2==1) { gotoxy(55,f);printf("%d",vect[i]); f=f+1; } Dentro del segundo for realizamos un if donde nos indica si el residuo de la división 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 función. 125
  • 130.
    } } void main() Comenzaremos conel programa { do { Abrimos la sentencia. clrscr(); Limpiar pantalla. bdob(); Llamamos a la función borde. gotoxy(21,3);printf("<<BUSQUEDA IMPARES_VECTORES>>"); DE # PARES E 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>>"); Impresión de mensajes f=9; Posición de fila for(i=1;i<=lim;i++) Este for nos indica el límite 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. gotoxy(18,f);printf(" "); gotoxy(18,f);scanf("%d",&vect[i]); } 126 Declaramos la posición de fila.
  • 131.
    while(vect[i]<3 || vect[i]>33); f=f+1; } busq(lim); Llamamosa la función 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. } Corrido del Programa 127
  • 132.
    45.- Diseñe unprograma 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 para las posiciones impares del vector. Librerías DOCUMNTACION #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("-"); gotoxy(80,i);printf("-"); } for(i=1;i<=80;i++) { gotoxy(i,2);printf("-"); gotoxy(i,24);printf("-"); } } 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(); 128 Declaración de variables Función global para el borde, e inicio del ciclo, da color Inicio de la función factor y del ciclo for Condición para calcular los factores impares y pares Inicio del programa principal Inicio de el ciclo do while llamamos al borde ye ingresamos el limite
  • 133.
    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); 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(); } CORRIDO DEL PROGRAMA 129 Ingreso de los números pares Ingreso de los impares, repetición del proceso y fin del programa
  • 134.
    46.- Diseñe unprograma 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> Librerías, declaración de int i,conta,residuo,j,op,fila=5,k,aux,limite,vec[10]; variables he inicio de la void borde() función borde { for(i=1;i<=79;i++) { gotoxy(i,1);printf("-"); gotoxy(i,23);printf("-"); } Proceso de borde for(i=1;i<=23;i++) { gotoxy(1,i);printf("-"); gotoxy(79,i);printf("-"); } } void ingreso() { int fila=5; for(i=1;i<=limite;i++) { Inicio de la función para el do ingreso con un rango entre { 6 y 26 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++) { Inicio de función for (j=1;j<=limite;j++) ascendente calculamos { con dos for y una if (vec[i]<vec[j]) condición Y para la { aux=vec[i]; impresión un for mas para vec[i]=vec[j]; el vector vec[j]=aux; } } } for (i=1;i<=limite;i++) { gotoxy(40,fila);printf("%d",vec[i]); 130
  • 135.
    fila=fila+1; } } void descendente () { Iniciode función int fila=5; descendente calculamos for (i=1;i<=limite;i++) con dos for { for (j=1;j<=limite;j++) { if (vec[i]>vec[j]) { aux=vec[i]; vec[i]=vec[j]; vec[j]=aux; } Usamos una } condición Y para } la impresión un for (i=1;i<=limite;i++) for mas para el { vector gotoxy(55,fila);printf("%d",vec[i]); 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(); } 131 Inicio del programa principal llamamos funciones he ingresamos el limite
  • 136.
  • 137.
    47.- Diseñe unprograma 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. ANALISIS En este programa presentado, vamos a trabajar con funciones y vectores donde tenemos que la posiciones impares se me ubique el número ingresado y el factorial tiene que ubicarse en las posiciones pares del vector donde después vamos a ordenar el vector en orden ascendente y en orden descendente en el cual también utilizaremos una variable “op” que se utilizara para la opción desea continuar SI o NO, esto se lo realiza con el Laso DO – WHILE que permite generar nuevamente el programa. CODIFICACION Ingreso las librerías Declaración de variables #include<stdio.h> #include<conio.h> int op,i,j,limite,au,aux,mu,factor,fa,fila,vecto[15]; void borde() Función borde { for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); Este proceso es para realizar el borde gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); 133
  • 138.
    } } Función de laserie void facto() { fila=9; mu=0; Igualación de las variables au=1; factor=1; Que el for vaya hasta el límite for(i=1;i<=limite;i++) { if(i%2==1) { mu=mu+fa; vecto[i]=mu; En este proceso es para que podamos sacar los números impares donde el número ingresado lo dividimos para 2 sino caso contrario sacamos el factor y después vamos a imprimir el vector [i] donde después vamos a ir sumando la fila más 1 para la posición del } else { factor=factor*au; au=au+1; vecto[i]=factor; } gotoxy(7,fila);printf("%d",vecto[i]); 134
  • 139.
    fila=fila+1; } } Ingresamos una nueva funciónque se llama orden void orden() { for(i=1;i<=limite;i++) { 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 externo donde el vector [i]sea menor que el vector[j] después vamos a mandar otro for que vaya hasta el límite y posteriormente vamos a imprimir el vector [i] aux=vecto[i]; vecto[i]=vecto[j]; vecto[j]=aux; } } } fila=9; for(i=1;i<=limite;i++) { gotoxy(20,fila);printf("%d",vecto[i]); fila=fila+1; } fila=9; for(i=1;i<=limite;i++) 135
  • 140.
    Posición en donde quequiero que se me imprima printf { for(j=1;j<=limite;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 externo donde el vector [i]sea mayor que el vector[j] { if(vecto[i]>vecto[j]) { aux=vecto[i]; vecto[i]=vecto[j]; vecto[j]=aux; } } } fila=9; Después vamos a mandar otro for que vaya hasta el límite y después vamos a imprimir el vector [i] for(i=1;i<=limite;i++) { gotoxy(35,fila);printf("%d",vecto[i]); fila=fila+1; } } void main() Abro el programa { do Abro el do { Limpio de pantalla clrscr(); Llama a la función de borde borde(); Posición en donde que quiero que se me imprima printf gotoxy(25,3);printf("FacPares/Impares"); 136 Pide el límite que quieres imprimir
  • 141.
    gotoxy(12,5);printf("Ingrese el limite: ");scanf("%d",&limite); Pideel factor que quieres imprimir gotoxy(10,7);printf("Factor: ");scanf("%d",&fa); Llamo a la función facto facto(); Llamo a la función orden orden(); Se me imprime mensaje para continuar o terminar el programa Cierro la función de do-while Cierro el programa gotoxy(5,20);printf("Presione 1 para repetir el proceso o 0 para salir: ");scanf("%d",&op); } while(op==1); getch(); } 137
  • 142.
  • 143.
    48.-Diseñe un programacon funciones y vectores que me permita ingresar un sin número de elementos en un vector entre 3 y 25, recorrer el vector y encontré todos aquellos valores que sean números primos asígnelos en un nuevo vector y preséntelos ordenados en forma ascendente y descendente. ANÁLISIS Para realizar este programa necesitamos utilizar funciones tanto para el borde como para los números primos y para ordenar dichos números 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 función a la cual denominaremos pri ya que también dentro de esta función realizaremos las operaciones para encontrar los números primos para lo cual necesitamos de la condición if y de ciclos for los cuales nos ayudaran a generar dichos números.  Par ordenar el vector de forma ascendente y descendente necesitamos de una función denominada as para la forma ascendente y de una función 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.  Además utilizamos un ciclo do while para repetir este proceso el número de veces que el usuario desee. . DOCUMENTACIÓN #include<conio.h> Ingresamos las librerías que vamos a utilizar #include<stdio.h> int f1, aux, num, i, j, f, vect[100]; Ingresamos las variables que vamos a utilizar, son variable de tipo enteras int vectser[100], lim, op, cont; void borde() 139
  • 144.
    { int i; clrscr(); gotoxy(1,1);printf("É"); gotoxy(80,1);printf("»"); for(i=2;i<=79;i++) Aquí realizamosuna función para poder realizar el borde en el programa { gotoxy(i,1);printf("Í"); gotoxy(i,24);printf("Í"); } gotoxy(1,24);printf("È"); gotoxy(80,24);printf("¼"); for(i=2;i<=23;i++) { gotoxy(1,i);printf("º"); gotoxy(80,i);printf("º"); }} void primo(int l) { Aquí realizamos una función para poder verificar si un número es o no f=9; f1=9; for(j=1;j<=l;j++) { do { Aquí imprimimos y validamos el vector ingresado que este entre parámetro que nos dieron para realizarlo gotoxy(18,f);printf(" "); gotoxy(18,f);scanf("%d",&vect[j]); 140
  • 145.
    } while(vect[j]<3 || vect[j]>25); f=f+1; Sumamosa la fila (f=f+1), y igualamos a cero el cont=0; for(i=1;i<=vect[j];i++) { Este for es para que se imprima en las filas pares if(vect[j]%i==0) { cont=cont+1; }} if(cont==2) Este if es para que se imprima en las filas impares { vectser[j]=vect[j]; gotoxy(34,f1);printf("%d",vectser[j]); f1=f1+1; }}} void orden(int l) Esta función 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 límite y se pregunte a las dos posiciones, y después de le pregunta con un if si el vector [i] es < que el vector for(j=1;j<=l;j++) { if(vectser[i]<vectser[j]) { aux=vectser[i]; vectser[i]=vectser[j]; Aquí utilizamos una variable auxiliar para que tome el valor de otra variable vectser[j]=aux; 141
  • 146.
    }}} gotoxy(29,9);printf("ASCE"); f=11; Igualamos la filaa 11 for(i=1;i<=l;i++) { gotoxy(39,f);printf("%d",vectser[i]); Imprimimos al vector de manera ascendente f=f+1; } for(i=1;i<=l;i++) Estos for son para que se imprima hasta un cierto límite. { for(j=1;j<=l;j++) { if(vectser[i]>vectser[j]) { aux=vectser[i]; Aquí utilizamos una variable auxiliar para que tome el valor de otra variable vectser[i]=vectser[j]; vectser[j]=aux; }}} gotoxy(52,9);printf("DESC"); Imprimimos al vector de manera descendente f=11; for(i=1;i<=l;i++) { gotoxy(62,f);printf("%d",vectser[i]); f=f+1; }} void main() Realizamos el programa principal { 142
  • 147.
    do Ponemos una sentenciado-while para que se pueda repetir n veces. { clrscr(); borde(); gotoxy(21,3);printf("BUSQUEDA DE NUMRS- PARES E IMPARES"); gotoxy(5,5);printf("limite: ");scanf("%d",&lim); Ingresamos el límite e imprimimos un título gotoxy(13,7);printf("VECTOR"); gotoxy(26,7);printf("#PRIMOS"); gotoxy(47,7);printf("#IMPARES"); primo(lim); Llamamos a las demás funciones que ya realizamos. 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 } 143 Cerramos el lazo do-while
  • 148.
  • 149.
    49.- Diseñe unprograma 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. ANÁLISIS 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 posición e imprimirla necesitamos de una función 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 añadirle color.  Para encontrar los datos de la cadena de caracteres del vector necesitamos de una nueva función a la cual la denominaremos void cont para realizar dicho proceso requerimos de un ciclo for el cual nos permitirá contar los caracteres ingresados además requerimos de otro ciclo for el mismo que nos ayudara a imprimir dichos datos.  Además utilizamos un ciclo do while para repetir este proceso el número de veces que el usuario desee. DOCUMENTACIÓN #include<stdio.h> #include<conio.h> Librerías #include<string.h> #include<ctype.h> char cadena[20],vecimpar[20]; int i,fi,op,n,h; void borde() Declaracion de variables tipo caracter Declaracion de variables enteras Inicio función borde { 145
  • 150.
    Inicio ciclo for for(i=1;i<=80;i++) { color textcolor(i+1); gotoxy(i,1);cprintf("*"); Impresión borde gotoxy(i,24);cprintf("*"); Fin ciclo for } for (i=1;i<=24;i++) Inicio ciclo for { color textcolor(i+1); gotoxy(1,i);cprintf("*"); Impresión borde gotoxy(80,i);cprintf("*"); } Fin ciclo for } Fin función borde void cad() Inicio función cad { Palabra reservada que permite funcionar ciclo do while flushall(); gotoxy(30,5);gets(cadena); Impresión cadena l=strlen(cadena); Igualación limite palabra reservada strlen Igualación fila a 9 fila=9; for(i=0;i<l;i++) Inicio ciclo for { textcolor(i+1); color gotoxy(23,fi);cprintf("%c",cadena[i]); fila=fila+1; } Contador mas 1 Fin ciclo for Fin función cadena 146 Impresión vector ingresante
  • 151.
    } void cont() Inicio funcióncont { h=1; Igualación variable a 1 for(i=0;i<n;i++) Inicio ciclo for { Igualación vector auxiliar a vector ingresante vecimpar[h]=cadena[i]; h=h+1; Contador mas 1 } Fin ciclo for fila=8; Igualación variable fila a 8 for(i=0;i<h;i++) Inicio ciclo for { gotoxy(45,fi);printf("%c",vecimpar[i]); fila=fila+1; } Impresión vector resultante Contador mas 1 Fin ciclo for } Fin funcion cad void main() Inicio función principal { do Inicio ciclo do while { clrscr(); borde(); Blanqueo de pantalla Se llama a la funcion borde gotoxy(25,3);printf("<< CARACTERES >>"); gotoxy(8,5);printf("*.CARACTERES : "); Impresión titulos gotoxy(15,7);printf("<< V REALIZADO>>"); 147
  • 152.
    gotoxy(38,7);printf("<< V.RESULTANTE>>"); cad(); Se llamaa la funcion cad cont(); Se llama a la función cont gotoxy(12,22);printf("PULSE 1 PARA CONTINUAR O 0 PARA SALIR : ");scanf("%d",&op); } while(op==1); Fin ciclo do while getch(); } Fin programa CORRIDO DEL PROGRAMA 148 Impresión repetición
  • 153.
    50.- Diseñe unprograma 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. ANALISIS:        Primero empezamos abriendo nuestras bibliotecas Después validamos nuestras variables globales, que servirán para la ejecución de nuestro programa, teniendo en cuenta que estamos ocupando char que servirá para hacer cadena de caracteres. Realizamos nuestra primera función llamada borde que nos servirá para más después abrir en nuestras funciones realizadas Comenzamos a realizar nuestra primera función 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, además ingresaremos el carácter y un proceso de for en el cual se almacenen un vector con sus respectivos caracteres. Después de esto comenzaremos otra función 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. #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); Abrimos las librerías Iniciamos los valores de nuestro programa gotoxy(i,1);cprintf("*"); gotoxy(i,24);cprintf("*"); } for(i=2;i<=23;i++) { textcolor(17); Nuestro borde 149
  • 154.
    gotoxy(1,i);cprintf("*"); gotoxy(80,i);cprintf("*"); } } Función que ocuparemos voidnomb() después { flushall(); Permite leer el carácter gotoxy(12,5);gets(nombre); n=strlen(nombre); Permite almacenar en otro vector fi=5; for(i=0;i<n;i++) { if(islower (nombre[i])) { For para ingresar el vector, nombre[i]=toupper(nombre[i]); utilizamos la función textcolor para textcolor(i+1); poner color a las letras gotoxy(40,fi);cprintf("%c",nombre[i]); 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 { clrscr(); Borrado de pantalla y llamado de la función borde(); borde nomb(); Llamamos a las funciones textcolor(2); gotoxy(12,18);cprintf("ingrese el caracter ");scanf("%c",&a); Imprimir el título y subtítulos de nuestro programa textcolor(3); for(i=0;i<n;i++) { if(nombre[i]==a) For para su limite y el if para buscar { su posición 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); 150 Cerramos la sentencia do while
  • 155.
    getch(); } Pausado en elprograma y cerrado del programa CORRIDO DEL PROGRAMA: 151
  • 156.
    51.- Diseñe unprograma utilizando funciones y vectores que me permita leer una cadena de caracteres, leer el vector y encontrar todos los datos que se encuentren en posición de impares del vector y asignarlos a un nuevo vector, presente el nuevo vector ordenado.  ANÁLISIS Empezamos abriendo las librerías para activar funciones, utilizamos variables de tipo enteras y alfabéticas tres funciones con sentencia “for”, una para el borde y las dos restantes para realizar los procesos y al impresión de las letras qu están 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 Librerías.- colección de clases y #include<stdio.h> funciones, escritas en el núcleo del lenguaje. #include<conio.h> #include<string.h> Variables.- son un tipo de dato #include<ctype.h> char nombre[20],vecimpar[20]; Alfabéticas Enteras int i,fi,op,n,h; void borde() { for(i=1;i<=79;i++) { textcolor(9); Sentencia “for” para gotoxy(i,1);printf("±"); realizar el borde gotoxy(i,24);printf("±"); } for(i=2;i<=23;i++) { textcolor(9); gotoxy(1,i);printf("±"); gotoxy(80,i);printf("±"); } } void nomb() Funciones.- Las funciones son { flushall(); bloques de código utilizados Color para el texto textcolor(3); para dividir un programa en Lectura de gotoxy(5,5);cprintf("TEXTO:"); partes más pequeñas, cada textcolor(i+1); variables una de las cuáles tendrá una gotoxy(12,5);gets(nombre); tarea determinada. n=strlen(nombre); Impresión del vector 152
  • 157.
    fi=9; for(i=0;i<n;i++) Un vector, tambiénllamado { array(arreglo) textcolor(3); unidimensional, es una gotoxy(5,7);cprintf("VECTOR"); estructura de datos que textcolor(i+1); permite agrupar elementos gotoxy(8,fi);cprintf("%c",nombre[i]); del mismo tipo y fi=fi+1; almacenarlos en un solo } bloque de memoria juntos, } uno después de otro. A este void impar() { grupo de elementos se les h=1; identifica por un mismo for(i=0;i<n;i++) nombre y la posición en la { que se encuentran. La if(i%2==0) primera posición del array es { la posición 0. vecimpar[h]=nombre[i]; h=h+1; } } Sentencia “for” para la fi=8; impresión de las letras for(i=0;i<h;i++) en posiciones impares { Color para el texto textcolor(3); gotoxy(15,7);cprintf("POSICIONES"); textcolor(i+1); gotoxy(20,fi);cprintf("%c",vecimpar[i]); fi=fi+1; } } void main() Inicio del programa { Sentencia do while do { Proceso de repetición Borrar pantalla clrscr(); Funcion borde 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); getch(); Pausa } Fin del programa 153
  • 158.
  • 159.
    52.- Diseñe unprograma utilizando funciones y vectores que me permita leer una cadena de caracteres, y presentarlos de forma invertida.  ANÁLISIS Empezamos abriendo las librerías para activar funciones, utilizamos variables de tipo enteras y alfabéticas tres funciones con sentencia “for”, una para el borde y las dos restantes para realizar los procesos y al impresión de la frase invertida, 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 Librerías.- colección de clases #include<stdio.h> funciones, escritas en el núcleo del lenguaje. #include<conio.h> #include<string.h> Variables.- son un tipo de dato char nombre[20],vecimpar[20]; Alfabéticas int i,fi,op,n,h,j,aux,col; Enteras void borde() { for(i=1;i<=80;i++) { textcolor(5); gotoxy(i,1);cprintf("±"); Sentencia “for” para gotoxy(i,24);cprintf("±"); realizar el borde } textcolor(5); for(i=2;i<=24;i++) { gotoxy(1,i);cprintf("±"); gotoxy(80,i);cprintf("±"); } } void nomb() { Funciones.- Las funciones son flushall(); Color para el texto bloques de código utilizados textcolor(2); para dividir un programa en gotoxy(5,5);cprintf("TEXTO"); partes más pequeñas, cada gotoxy(12,5);gets(nombre); Lectura de una de las cuáles tendrá una variables tarea determinada. n=strlen(nombre); fi=8; Impresión del vector 155 y
  • 160.
    for(i=0;i<n;i++) { textcolor(2); gotoxy(5,7);cprintf("VECTOR"); textcolor(i+1); gotoxy(9,fi);cprintf("%c",nombre[i]); fi=fi+1; } fi=7; Sentencia “for” parala for(i=n;i>=0;i--) impresión DE LA FRASE { INVERTIDA textcolor(2); gotoxy(15,7);cprintf("INVERTIDO"); textcolor(i+1); gotoxy(20,fi);cprintf("%c",nombre[i]); fi=fi+1; } } void main() Inicio del programa { Sentencia do while do Proceso de repetición { Borrar pantalla clrscr(); Funcion borde borde(); textcolor(5); gotoxy(15,3);cprintf("VECTORES"); nomb(); Funciones textcolor(5); gotoxy(5,22);cprintf("Desea repetir 1 Salir 0: ");scanf("%d",&op); }while(op==1); getch(); Pausa } Fin del programa 156
  • 161.
  • 162.
    53.- Diseñe unprograma utilizando vectores y funciones que me permita leer una cadena de caracteres y presentarla de forma invertida. ANÁLISIS: En este programa hemos utilizado la variable char para declaración con caracteres la palabra, un get para ingresar datos con caracteres, un “for” para invertir al vector ingresado e imprimir el en un nuevo vector todo esto se hace en una función global y al último se llama en una función principal void main. CODIFICACIÓN: #include<stdio.h> #include<string.h> Librerías #include<conio.h> int i,op,fila,a; Declaración de variables char nom[40]; void borde() { for(i=1;i<=80;i++) Función global para el borde, e inicio del ciclo, da color { textcolor(i+1); gotoxy(i,1);printf("!"); Impresión del borde, cierre del ciclo gotoxy(i,24);printf("!"); } for(i=2;i<=24;i++) { Función global para el borde, e inicio del ciclo, da color textcolor(i+1); gotoxy(1,i);printf("!"); Impresión del borde gotoxy(80,i);printf("!"); } Cierre del ciclo y de la función } void inver() 158 Función global e inicio
  • 163.
    { flushall(); gotoxy(20,6);printf("Ingrese la palabra:");gets(nom); a=strlen(nom); Ingreso de datos con caracteres y almacenarían en auxiliar fila=9; for(i=0;i<a;i++) Ciclo “FOR” ,color para e vector { textcolor(i+1); gotoxy(30,fila);cprintf("%c",nom[i]); fila=fila+1; Impresión del vector en forma vertical } fila=8; for(i=a;i>=0;i--) Proceso de la forma invertida con ciclo “for” { textcolor(i+1); gotoxy(45,fila);cprintf("%c",nom[i]); Impresión del nuevo vector invertido y con color fila=fila+1; } Cierre del ciclo y de la función } void main() Función principal e inicio { do Inicio del ciclo “do-while” { clrscr(); Limpiado de pantalla y llamado de la función borde borde(); gotoxy(32,2);printf("**Cadena de Caracteres Invertida**"); Impresión de mensajes gotoxy(27,8);printf("Vector"); gotoxy(43,8);printf("Inversion"); Llamado de la función global inver(); 159
  • 164.
    gotoxy(12,22);printf("Digite 1 paracontinuar o 0 para salir : ");scanf("%d",&op); }while(op==1); Cierre del ciclo getch(); Pausa y cierre del programa } CORRIDO DEL PROGRAMA: 160
  • 165.
    54.- Diseñe unprograma 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 librerías declaro dos variables tipo carácter y 7 variables de tipo entero utilizo 3 funciones la primera para el diseño del borde en pantalla la segunda función para sacar el proceso de encontrar las consonantes y la tercera función es la principal utilizo un do while para repetir el proceso CODIFICACION #include<conio.h> LIBRERIAS #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); FUNCIÓN BORDE for(i=1;i<=80;i++) { gotoxy(i,1);cprintf("*"); gotoxy(i,24);cprintf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);cprintf("*"); //IMPRECION DE * gotoxy(80,i);cprintf("*"); } //FIN DEL CICLO FOR } // FIN DEL CICLO DE LA FUNCION DEL BORDE // void caracter() { FUNCION PARA SACAR CONSONANTES gotoxy(5,5);printf("Cadena:");gets(cad); //IMPRIMO UN MENSAJE CON LA PALABRA CADENA 161
  • 166.
    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("%cn",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 162
  • 167.
    { // INICIODE 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 CARÁCTER 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 DEL PROGRAMA 163
  • 168.
    56.- Diseñe unprograma 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 números primos y asignarlos a un nuevo vector, presente el vector resultante ordenado en forma ascendente y descendente. ANÁLISIS 1. Codificamos el borde dentro de una funciones 2. Dentro de otra funciones ingresamos un límite y un factor 3. Si la posiciones es par debemos condicionar el valor ingresado entre 3 y 23 4. Si la posiciones es impar realizamos el proceso para que se genere el factor 5. Realizamos otra función para imprimir los números 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 función para ordenar de forma ascendente los valores asignados al vector de números primos 8. De igual manera utilizamos una función para ordenar de forma descendente los valores asignados al vector de los números primos. 9. Abrimos la función del programa principal 10. Llamamos las funciones previamente codificadas DOCUMENTACIÓN Librerías Declaración de Variables int Inicio de función borde Lazo For Fin de función #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); gotoxy(i,1);cprintf("*"); gotoxy(i,24);cprintf("*"); } for(i=1;i<=24;i++) { textcolor(i); gotoxy(1,i);cprintf("*"); gotoxy(80,i);cprintf("*"); } } 164
  • 169.
    Función de ingreso Ingresose impresiones Inicializaciones Lazo For Fin de función Funciones primos Inicialización variables Lazo For Condición If Fin función 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; } } 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; }}} 165
  • 170.
    Función Ascendente Lazo For Finde función Función descendente Lazo for Fin de función Función principal 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"); gotoxy(40,fila);printf("%d",vec[i]); fila=fila+1; } }//cierre 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"); gotoxy(65,fila);printf("%d",vec[i]); fila=fila+1; } }//cierre void main() { 166
  • 171.
    Llamado de funciones LazoDo While Fin de función do { clrscr(); borde(); ingreso(); primos(); ascendente(); descendente(); getch(); gotoxy(10,22);printf("Presione 1/0>> ");scanf("%d",&op); }while(op==1); } CORRIDO DEL PROGRAMA 167
  • 172.
    57.- Diseñe un programautilizando funciones y matrices que me permita visualizar los datos en una matriz y otra matriz resultante con los datos ingresados. ANÁLISIS En este programa utilizaremos funciones tanto para el borde como para ingresar y presentar los datos de nuestra matriz, esencialmente la utilización 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. DOCUMENTACION #include<stdio.h> Librerías #include<conio.h> int j,i,k,op,matriz1[10][10],col=10,fila=8,limite,datos,sali,f; Declaración de variables void borde() { for(k=2;k<=80;k++) { gotoxy(k,2);printf("-"); gotoxy(k,24);printf("-"); } Función para el diseño del borde for(k=2;k<=24;k++) { gotoxy(2,k);printf("-"); gotoxy(80,k);printf("-"); } } void ing(int datos) { col=10; fila=8; for(i=1;i<=limite;i++) { Función para el ingreso de los for(j=1;j<=limite;j++) { 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++) Función para la impresión de { for(j=1;j<=limite;j++) nuestra matriz utilizando ciclos FOR 168
  • 173.
    { gotoxy(col,fila); printf("%d",matriz1[i][j]); col=col+5; } col=40; fila=fila+1; } } Cuerpo principaldel programa void main() { do Ciclo DO-while para repetir n veces { clrscr(); Blanqueo de pantalla borde(); Llamado de la función del borde gotoxy(3,3); printf("Ingrese un límite: "); 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 pantalla } CORRIDO DEL PROGRAMA 169 Ingreso del límite de datos Ciclo DO-while para repetir n veces
  • 174.
    58.- Diseñe unprograma 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 librerías y las variables globales abrimos una función 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 función del programa ingresamos en una variable para que se almacene el factor, también 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 función para llamar al proceso ingreso un lazo repetitivo, un limpiador de pantalla,llamo a la función 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. DOCUMENTACION #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++) { gotoxy(i,1);cprintf("*"); gotoxy(i,24);cprintf("*"); } PROCESO DEL BORDE for(i=1;i<=24;i++) { gotoxy(1,i);cprintf("*"); gotoxy(80,i);cprintf("*"); } } 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); 170 ENUNCIADOS
  • 175.
    columna=10; fila=10; for(i=1;i<=datos; i++) PROCESO DELA 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 gotoxy(columna,fila);printf("%d",matriz[i][j]); EL FACTOR columna=columna+4; } columna=50; fila=fila+2; } } SE CIERRA LA FUNCION 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 171
  • 176.
  • 177.
    59.- Diseñe unprograma utilizando funciones y matrices que me permita Imprimir una matriz cuadrática de ceros excepto la diagonal principal. ANALISIS Ingresamos las librerías introducimos las variables globales abrimos la función del borde ingresamos un textcolor(YELLOW); para darle color al diseño mediante lazos for asemos el margen de la pantalla y cerramos la función abrimos la función del programa para la matriz visualizamos el límite que se desea ingresar ingresamos dos lazos for con (i,j) para formar a la matriz, ingresamos una condición si el número de la fila es igual al de la columna se imprima con unos caso contrario de ceros cerramos la función. 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. DOCUMENTACION #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++) { gotoxy(i,1);cprintf("*"); gotoxy(i,24);cprintf("*"); } for(i=1;i<=24;i++) PROCESO DEL BORDE { gotoxy(1,i);cprintf("*"); gotoxy(80,i);cprintf("*"); } } CIERRO LA FUNCION void programa(int datos) FUNCION DEL PROGRAMA { ABRIR LA FUNCION gotoxy(3,5);cprintf("Limite: ");cscanf("%d",&limite); INGRESAR UN LIMITE for(i=1;i<=limite;i++) { ORDENAR LA MATRIZ for(j=1;j<=limite;j++) { if(i==j) { matriz[i][j]=1; 173
  • 178.
    gotoxy(columna,fila);cprintf("%d",matriz[i][j]); REALIZA UNA CONDICION columna=columna+5; } else { matriz[i][j]=0; gotoxy(columna,fila);printf("%d",matriz[i][j]); columna=columna+5; CASOCONTRARIO } } fila=fila+1; columna=13; } } SE CIERRA LA FUNCION 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 } SE CIERRA LA FUNCION CORRIDO DEL PROGRAMA 174
  • 179.
    61.- Diseñe unprograma 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. ANÁLISIS Para este programa utilizamos funciones para llamar al procedimiento para realizar el ejercicio también 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. DOCUMENTACIÓN #include<conio.h> Librerías #include<stdio.h> Declaración de variables int fil, col, aux, i, j, mat[10][10], vect[10], lim, op, a, b, c, h; void bdob() { int i; clrscr(); gotoxy(1,1);printf("É"); gotoxy(80,1);printf("»"); for(i=2;i<=79;i++) Función global para el borde { gotoxy(i,1);printf("Í"); gotoxy(i,24);printf("Í"); } gotoxy(1,24);printf("È"); gotoxy(80,24);printf("¼"); for(i=2;i<=23;i++) { 175
  • 180.
    gotoxy(1,i);printf("º"); gotoxy(80,i);printf("º"); } } void diag() Inicio dela función para determinar las diagonales { col=5; fil=8; a=1; b=0; c=0; Condición para calcular las diagonales for(i=1;i<=lim;i++) { for(j=1;j<=lim;j++) { c=a+b; a=b; b=c; Proceso para calcular la serie del fibonasi mat[i][j]=c; gotoxy(col,fil);printf("%d",mat[i][j]); col=col+4; } col=5; fil=fil+3; } } 176
  • 181.
    void dprinc() { Inicio dela función calcular la diagonal principal col=21; fil=8; h=1; for(i=1;i<=lim;i++) { Condición para calcular la diagonal for(j=1;j<=lim;j++) { if(i==j) { vect[h]=mat[i][j]; h=h+1; gotoxy(col,fil);printf("%d",mat[i][j]); Imprimimos la matriz col=col+4; } } fil=fil+3; } } void dsec() { Función para calcular la diagonal secundaria col=28; fil=8; j=lim; for(i=1;i<=lim;i++) 177
  • 182.
    { vect[h]=mat[i][j]; h=h+1; gotoxy(col,fil);printf("%d",mat[i][j]); j=j-1; Imprimimos la matriz col=col-4; fil=fil+3; } } voiddiag_vect() { fil=8; for(i=1;i<h;i++) { gotoxy(41,fil);printf("%d",vect[i]); fil=fil+2; } } void orden() { Función para ordenar las diagonales. fil=8; for(i=1;i<h;i++) { for(j=1;j<h;j++) { if(vect[i]<vect[j]) { 178
  • 183.
    aux=vect[i]; vect[i]=vect[j]; vect[j]=aux; } } } fil=8; Calculamos el vector descendente for(i=1;i<h;i++) { gotoxy(56,fil);printf("%d",vect[i]); fil=fil+2; } for(i=1;i<h;i++) Procesopara ordenar { for(j=1;j<h;j++) { if(vect[i]>vect[j]) { aux=vect[i]; Calculamos el vector ascendente vect[i]=vect[j]; vect[j]=aux; } } } fil=8; for(i=1;i<h;i++) { 179
  • 184.
    gotoxy(71,fil);printf("%d",vect[i]); fil=fil+2; } } void main() { do { Función dondea proseguimos a imprimir los datos 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>>"); 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(); } 180
  • 185.