Post on 28-Nov-2014
description
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
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
3
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.
4
¿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.
1
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.
2
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
3
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.
4
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
}
5
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 for switch
short long extern static default
continue break register sizeof
typedef
6
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”
7
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 Rango de valores signed char 1 byte -128 a 127 signed int 2 bytes -32768 a 32767
unsigned
Le indica a la variable que no va a llevar signo (valor absoluto).
Tamaño rango de valores unsigned char 1 byte 0 a 255 unsigned int 2 bytes 0 a 65535
short
Rango de valores en formato corto (limitado). Es el utilizado por defecto.
Tamaño rango de valores short char 1 byte -128 a 127 short int 2 bytes -32768 a 32767
long
Rango de valores en formato largo (ampliado).
Tamaño rango de valores long int 4 bytes -2.147.483.648 a 2.147.483.647 long double 10 bytes -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'
TIPO Tamaño Rango de valores char 1 byte -128 a 127 int 2 bytes -32768 a 32767 float 4 bytes 3'4 E-38 a 3'4 E+38 double 8 bytes 1'7 E-308 a 1'7 E+308
8
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.
9
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
10
#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");
11
printf("\nDirección: C\\ Mayor 25");
printf("\nHa salido la letra \'L\'");
printf("\nRetroceso\b");
printf("\n\tEsto 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:\includes\misfunc.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.
12
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 %d\n",a);
printf("El valor de b es %d\n",b);
printf("Por tanto %d+%d=%d",a,b,a+b);
}
Los modificadores más utilizados son:
%c Un único carácter
%d Un entero con signo, en base decimal
%u Un entero sin signo, en base decimal
%o Un entero en base octal
%x Un entero en base hexadecimal
%e Un número real en coma flotante, con exponente
%f Un número real en coma flotante, sin exponente
%s Una cadena de caracteres
%p 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;
13
float c=932.5;
printf("%s a es %d\n",cad,a);
printf("%s b es %u\n",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 %9d\n",cad,a);
printf("%s b es %ld\n",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.
14
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.
15
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; }
16
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;
17
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("%d\n",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;
18
do{
printf("1.- Comenzar\n");
printf("2.- Abrir\n");
printf("3.- Grabar\n");
printf("4.- Salir\n");
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 */
{
19
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 = %d\n",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++;
20
continue;
}
printf("%d\n",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("%d\n",num1);
printf("%d\n",num2); }
21
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
22
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("%d\n",num);
funcion(); /* llamada */
}
void funcion(void)
{
printf("%d\n",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 */
23
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;
24
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);
}
25
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 Pacho\n");
printf("Programa de ejemplo.\n\n");
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.
26
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'; .
27
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;
28
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.
29
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"
};
30
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;
31
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;
32
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:
33
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
34
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.
35
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);
36
FUNDAMENTOS DE PROGRAMACIÓN
Programa.- Conjunto de sentencias ordenadas secuencialmente para generar
procesos automáticos.
Lenguaje de Programación.- Sintaxis que permite generar instrucciones para
desarrollar aplicaciones.
ELEMENTOS DE UN
PROGRAMA
Datos de entrada
Procesos Resultados o
Datos de salida
ELEMENTOS DE UN LENGUAJE DE PROGRAMACIÓN
Identificadores
Librerías
Palabras reservadas
37
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.
38
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
{
} (op==1) while
39
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);
40
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; }
LIBRERIAS
VARIABLES
LECTURA DE
VARIABLES
INICIO
SENTENCIA SWICH
41
getch(); }
CORRIDO DEL PROGRAMA
FIN
42
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);
}
LIBRERIAS
VARIABLES
LECTURA DE
VARIABLES
INICIO
FIN
43
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);
LIBRERIAS
VARIABLES
LECTURA DE
VARIABLES
INICIO
44
}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
LECTURA DE
VARIABLES
CONDICIONAL “IF”
FIN
45
46
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
LIBRERIAS
VARIABLES
LECTURA DE
VARIABLES
INICIO
FIN
47
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))
LIBRERIAS
VARIABLES
LECTURA DE
VARIABLES
INICIO
48
{ 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
FIN
SENTECIA “IF”
49
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);
LIBRERIAS
VARIABLES
LECTURA DE
VARIABLES
INICIO
50
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) { 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
SENTECIA “IF”
51
CORRIDO DEL PROGRAMA
52
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 do-
while para que se repita el proceso, realizamos el proceso y presentamos
resultados.
DOCUMENTACIÓN #include<stdio.h> #include<conio.h> main() { 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"); 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); c=c+1;gotoxy(39,c);scanf("%2f",&vuni); vtotal=cant*vuni; d=d+1;gotoxy(55,d);printf("%.2f",vtotal); v=v+vtotal; 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; gotoxy(50,22); printf("iva: %.2f",iva); vtotal=sub+iva; gotoxy(40,23); printf("valor a pagar: %.2f",vtotal); getch(); }
LIBRERIAS
VARIABLES
LECTURA DE
INICIO
IMPRESION
IMPRESION
OPERASIONES
FIN
53
CORRIDO DEL PROGRAMA
54
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);
LIBRERIAS
VARIABLES
IMPRESION
INICIO
SENTECIA “IF”
55
} 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
56
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.
57
Análisis.- Utilizamos variables de tipo enteras, decimales y de carácter, do-
while 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> #include<conio.h> main () { 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,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"); 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); }
LIBRERIAS
VARIABLES
INICIO
LECTURA DE
58
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(); }
IMPRESION
IMPRESION
FIN
59
60
CORRIDO DEL PROGRAMA
61
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 #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(); }
LIBRERIAS
INICIO
VARIABLES
FIN
SENTENCIA “FOR”
62
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
#include<stdio.h>
#include<conio.h>
main()
{
int i,limite,fila=6,op;
do
{
fila=6;
clrscr();
for (i=1;i<=80;i++)
LIBRERIAS
INICIO
VARIABLES
63
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
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;
}
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
SENTENCIA “FOR”
SENTENCIA “FOR”
64
CORRIDO DEL PROGRAMA
65
Programa Nº612
Realizar un programa y visualizar los números primos.
Análisis.- Activamos la librerías, utilizamos variables de tipo enteras, do-
while para que cumpla la condición requerida, realizamos el proceso y
presentamos resultados
DOCUMENTACIÓN #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; } }
LIBRERIAS
INICIO
VARIABLES
SENTENCIA “FOR”
SENTENCIA “FOR”
66
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 #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("*"); }
LIBRERIAS
INICIO
VARIABLES
SENTENCIA “FOR”
67
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(); }
FIN
LECTURA DE
68
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 #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++)
LIBRERIAS
INICIO
VARIABLES
SENTENCIA “FOR”
69
{ 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(); }
FIN
70
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 #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("*");
LIBRERIAS
INICIO
VARIABLES
SENTENCIA “FOR”
71
} gotoxy(29,2);printf("NUMEROS PRIMOS"); gotoxy(6,4);printf("INGRESE EL LIMITE : ");scanf("%d",<); 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
72
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 #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++)
LIBRERIAS
INICIO
VARIABLES
SENTENCIA “FOR”
73
{ 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(); }
FIN
SENTENCIA “FOR”
74
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 #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++)
LIBRERIAS
INICIO
VARIABLES
SENTENCIA “FOR”
75
{ 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(); }
FIN
LECTURA DE
76
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 #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("*");
LIBRERIAS
INICIO
VARIABLES
SENTENCIA “FOR”
77
} 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(); }
FIN
IMPRESION
78
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
INICIO
VARIABLES
SENTENCIA “FOR”
79
} 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(); }
FIN
IMPRESION
80
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 #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++) {
LIBRERIAS
INICIO
VARIABLES
SENTENCIA “FOR”
81
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); for(i=1;i<=limit;i++) { gotoxy(colum,9);printf("%d",fibon); fibon=b+c; b=c; 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 FINALIZAR>> ");scanf("%d",&op); } while(op==1); getch(); }
FIN
LECTURA DE
LECTURA DE
OPERACIONES
82
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 #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();
LIBRERIAS
INICIO
VARIABLES
83
gotoxy(16,3);printf("SERIE NUMERADOR PRIMOS DENOMINADOR IMPARES"); 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(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; } 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("-"); 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
SENTENCIA “FOR”
SENTENCIA “FOR”
IMPRESION
84
CORRIDO DEL PROGRAMA
85
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 #include<conio.h> #include<stdio.h> #include<stdlib.h> void borde() { int i; 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("±"); } } 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("////////////////////"); 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();
LIBRERIAS
INICIO
VARIABLES
SENTENCIA “FOR”
IMPRESION
86
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; } FIN
IMPRESION
IMPRESION
IMPRESION
87
gotoxy(3,23);printf("1 PARA VOLVER AL MENU DE DATOS 0 PARA FINALIZAR: ");scanf("%d",&op); } while(op==1); getch(); }
FIN
88
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.
89
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(); }
FIN
LIBRERIAS
INICIO
VARIABLES
SENTENCIA “FOR”
90
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 #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++)
LIBRERIAS
INICIO
VARIABLES
SENTENCIA “FOR”
91
{ 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(); }
FIN
92
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 #include<stdio.h> #include<conio.h> #include<stdlib.h> int i,a,b,c; void borde () {
LIBRERIAS
INICIO
VARIABLES
93
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 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); } 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(" ");
SENTENCIA “FOR”
FUNSION
94
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
95
CORRIDO DEL PROGRAMA
96
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>
#include<conio.h> int i,a,b,c,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 numero()
{
do
{
gotoxy(24,4);printf(" ");
gotoxy(15,4);printf("Numero 1; ");scanf("%d",&a);
}
while(a>64 || a<4);
do
{
gotoxy(24,5);printf(" ");
LIBRERIAS
Declaración de variables
Impresión del margen
Inicio de la función void main
Inicio del do
Ingreso el primer numero
Inicio del do
Ingreso el segundo numero
Si ese número cumple con la condición
empleada pide el siguiente número
Inicio de la función borde
97
gotoxy(15,5);printf("Numero 2: ");scanf("%d",&b);
}
while(b>64 || b<4);
do
{
gotoxy(24,6);printf(" ");
gotoxy(15,6);printf("Numero 3: ");scanf("%d",&c);
}while(c>64 || c<4);
}
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);
}
}
if(b<=a && b<=c)
{
if(a<=c)
{
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);
}
Si ese número cumple con la condición
empleada pide el siguiente numero
Inicio del do
Ingreso el tercer numero
Inicio de la función void orden
Proceso para presentar
los números ingresados
en forma ordenada
ascendentemente.
98
}
gotoxy(15,7);printf("El orden es:");
}
void main()
{
do
{
clrscr();
borde();
numero();
orden();
gotoxy(15,22);printf("Desea salir 1/0: ");scanf("%d",&op);
}
while(op==1);
getch();
}
CORRIDO DEL PROGRAMA
Borrar pantalla
Llamar al borde
Llamar a la función
numero Llamar a la función orden
Fin del programa
Si la opción ingresada por el usuario es igual a 1 el
proceso se repetirá
Inicio de la función principal
99
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>
#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);
LIBRERIAS
Declaración de variables
Inicio de la función borde
Impresión del margen
Operaciones para sacar los
números perfectos
Inicio de la función void
perfecto
Operaciones para sacar los
números perfectos
100
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
void main()
{
do
{
f=9,dos=2,ex=1,ex2=2,expo2=2,expo3=3,f=9;
clrscr();
borde();
gotoxy(30,4);printf("SERIE DE NUMEROS PERFECTOS");
gotoxy(5,6);printf("Ingrese un limite: ");scanf("%d",&l1);
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);
getch();
}
CORRIDO DEL PROGRAMA
Borrar pantalla
Llamar al borde
Impresión del titulo
Ingreso del limite
Llamo a la función perfecto
Si la opción ingresada por el usuario es igual a 1 el
proceso se repetirá
Fin del programa
Impresión de los números
perfectos
Declaración de variables
Inicio de la función principal
101
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; // declaración de variables globales
void borde()
{
textcolor(BLUE);
for(i=1;i<=80;i++)
{
gotoxy(i,1);cprintf("*");
gotoxy(i,24);cprintf("*"); función del borde
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);cprintf("*");
gotoxy(80,i);cprintf("*"); // impression de *
} // fin del ciclo for
} // fin de la function borde
void seg () // function para la ecuacion
{ // inicio de la function
float a, b, c;
float x1, x2;
float x1real, x2real; /* complejas */
Activation de Liberia
102
float x1imag, x2imag; /* Partes imaginarias soluciones complejas
*/
float discriminante; /* Presentacion */
system ("cls"); /* Borrado de la pantalla */
borde();
gotoxy(10,3);printf("RESOLUCION DE LA ECUACION DE SEGUNDO
GRADO\n");
gotoxy(2,4);printf("==============================================
================\n");
gotoxy(10,5);printf("El programa soluciona la ecuación de segundo grado\n");
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 ecuacion\n");
printf(" %14d\n", 2);
printf(" %12gx + %gx + %g = 0\n", a, b, c); // impresiones
printf(" tiene por soluciones ");
if (discriminante == 0) // sentencia si dis es = a 0
{ // inicio de if
printf(" una raiz real doble\n"); // impresión
x1 = x2 = -b / (2*a); // calculo
printf(" x1 = %.2f\n", x1);
printf(" x2 = %.2f\n", x2); // impresión en pantalla
} // fin de if
else if (discriminante > 0) //si dis es mayor a cero
{ // cálculos
printf(" dos raices reales\n");
x1 = (-b + sqrt(discriminante)) / (2*a);
x2 = (-b - sqrt(discriminante)) / (2*a);
// impresiones
printf("x1 = %.2f\n", x1);
printf("x2 = %.2f\n", x2);
}
Else // caso contrario
{ //impresión en pantalla
printf("dos raíces complejas conjugadas\n");
//cálculos
x1real = x2real = -b / (2*a);
x1imag = sqrt(-discriminante) / (2*a);
x2imag = -sqrt(-discriminante) / (2*a);
// impresiones
103
printf("x1 = ( %.2f, %.2fi)\n", x1real, x1imag);
printf("x2 = ( %.2f, %.2fi)\n", x2real, x2imag);
} //fin del ese
} // fin de la función
void main () // inicio del programa
{ // llave de inicio
Do //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
104
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>
#include<conio.h>
int i;
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 main()
{
Librerías que vamos a utilizar en el programa
Declaramos la variable global
Realizamos la función para que se pueda
realizar un borde en nuestro programa
Realizamos el programa principal y declaramos la
variables que vamos a utilizar en el programa principal
105
int vector1[10],fila,op,lim;
do
{
clrscr();
borde();
gotoxy(25,3); printf("**VISUALIZAR DATOS VECTOR**");
gotoxy(10,5); printf("INGRESE EL LIMITE==>");
scanf("%d",&lim);
fila=6;
for(i=1;i<=lim;i++)
{
do
{
gotoxy(20,fila); printf(" ");
gotoxy(20,fila); scanf("%d",&vector1[i]);
}
while(vector1[i]<3 || vector1[i]>23);
fila=fila+1;
}
fila=6;
for(i=1;i<=lim;i++)
{
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);
}
while(op);
getch();
}
Aquí damos un limite al vector
para poder dar datos
numéricos a un limita vector
Ingresamos el limite
Ingresamos los números para que se llene
el vector previamente dado un limite
Damos o validamos los datos que estén entre 3 y 23
Aquí se visualiza el vector que
ingresamos en otra posición
Ingresamos otra opción para ver si se repite el programa n veces
Visualiza la opción y da por terminado el
programa
106
107
CORRIDO DEL PROGRAMA
108
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>
#include<stdlib.h>
int multivec[15],opc,divisionvec[15],
restavec[15],i,op,col,fila,vector1[15],vector2[15],
sumavec[15],limite1;
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 ingreso(int limite1)
Ingreso las
librerías
Declaración de
variables
Función borde
Este proceso
es para realizar
el borde
Función para ingresar los valores
de los vectores
109
{
col=12;
fila=8;
for(i=1;i<=limite1;i++)
{
gotoxy(col,fila); scanf("%d",&vector1[i]);
gotoxy(col+10, fila); scanf("%d",&vector2[i]);
fila=fila+1;
}
}
void suma(int limite1)
{
fila=8;
for(i=1;i<=limite1;i++)
{
sumavec[i]=vector1[i]+vector2[i];
gotoxy(40,fila); printf("%d",sumavec[i]);
fila=fila+1;
}
}
void resta(int limite1)
{
fila=8;
Ingresamos la posición en la cual
se va a visualizar los vectores
Utilizamos el for para poder
ingresar los valores del vector1 y
vector2 al final vamos sumando fila
para q vayan colocándose en las
posiciones correctas, cerramos la
laves del for y la llaves de la
función ingreso.
Función para realizar la suma
Abrimos con una llave
Ingresamos el valor de la fila en la que va a
empezar a visualizarse los datos del vector.
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.
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.
110
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;
}
}
void multi(int limite1)
{
fila=8;
for(i=1;i<=limite1;i++)
{
multivec[i]=vector1[i]*vector2[i];
gotoxy(40,fila); printf("%d",multivec[i]);
fila=fila+1;
}
}
void division(limite1)
{
fila=8;
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
Función para realizar la multiplicación
Abrimos con una llave
Ingresamos el valor de la fila en la que va a
empezar a visualizarse los datos del vector.
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.
Función para realizar la división.
Abrimos con una llave
Ingresamos el valor de la fila en la que va a
empezar a visualizarse los datos del vector.
111
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()
{
do
{
clrscr();
borde();
gotoxy(15,3); printf("**OPERACIONES CON VECTORES Y FUNCIONES**");
gotoxy(10,5); printf("1.-SUMA");
gotoxy(10,7); printf("2.-RESTA");
gotoxy(10,9); printf("3.-MULTIPLICACION");
gotoxy(10,11); printf("4.-DIVISION");
gotoxy(10,13); printf("QUE OPCION DESEA==>");
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
Utilizamos el ciclo do while para que el proceso se repita tantas veces desee el usuario
Limpia la pantalla.
Llama a la función borde.
Diseño de pantalla.
112
scanf("%d",&op);
switch(op)
{
case 1:
do
{
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
{
Utilizamos la sentencia
switch para el menú de
opciones.
113
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);
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");
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==>");
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.
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.
114
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);
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();
gotoxy(10,23);
printf("SI DESEA VOLVER AL MENU PRESIONE 1 CASO CONTRARIO
O==>");
scanf("%d",&op);
}
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.
Cerramos el switch
limpiamos pantalla y
volvemos a llamar a la
función borde.
Cerramos el ciclo do
while escribiendo un
mensaje
115
while(op==1);
getch();
}
CORRIDO DEL POGRAMA
Pausa.
Cerramos la función
main.
116
117
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>
#include<stdlib.h>
int i, j=1, f, vect[10], vectpar[10], vectimp[10], op, l;
void bdob()
{
int i;
clrscr();
gotoxy(1,1);printf("*");
gotoxy(80,1);printf("*");
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("*");
}
}
Activación de librería esto habilita
procesos para el programa
Declaración de variables
que se utilizaran en el
programa
Función borde
Generación del borde
utilizando posiciones e
imprimiendo el borde que
va a ir en pantalla
118
void par()
{
j=1;
for(i=1;i<=l;i++)
{
if(i%2==0)
{
vectpar[j]=vect[i];
j=j+1;
}
}
f=10;
for(i=1;i<j;i++)
{
gotoxy(39,f);printf("%d",vectpar[i]);
f=f+1;
}
}
void impar()
{
j=1;
for(i=1;i<=l;i++)
{
if(i%2==1)
{
vectimp[j]=vect[i];
j=j+1;
}
}
f=10;
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
Función para ver si la posición es
impar
Comparación si la función es impar
Almacenamiento en un nuevo
vector
119
for(i=1;i<j;i++)
{
gotoxy(60,f);printf("%d",vectimp[i]);
f=f+1;
}
}
void main()
{
do
{
flushall();
f=10;
clrscr();
bdob();
gotoxy(36,3);printf("VECTORES");
gotoxy(5,5);printf("Ingrese el limite>> ");scanf("%d",&l);
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);
do
{
gotoxy(20,f);printf(" ");
gotoxy(20,f);scanf("%d",&vect[i]);
}
while(vect[i]<6 || vect[i]>26);
f=f+1;
}
par();
Impresión de datos de las
posiciones impares
Programa principal
Do while este nos ayuda a
utilizar el programa cuantas
veces deseemos
Limpia pantalla
Llama a la función del borde
Pide ingresar un limite de
generación de datos
Ingreso de datos del vector
Validación de los datos, estos
deben ser mayor que seis y
menor que veinte y seis
Llama a la función par
Llama a la función impar
120
impar();
gotoxy(3,22);printf("PRESIONE 1 PARA CONTINUAR O 0CASO CONTRARIO::>
");scanf("%d",&op);
}
while(op==1);
getch();
}
CORRIDO DEL PROGRAMA
Cierre del do while
Cierre o fin del programa
121
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;
float f;
void borde()
{
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)
{
a=1;
b=0;
LIBRERIAS QUE HABILITAN PROCESOS
PARA LA ELABORACION DEL
PROGRAMA.
ELABORACION DE UN BORDE PARA
DISEÑO DE PANTALLA UTILIZANDO
POSICIONES.
FUNCION SERIE DONDE GENERARA
EL FIBONACI Y EL FACTOREAL
IGUALACION DE VARIABLE. DESDE
QUE NUMERO DESEAMOS QUE
EMPIESE
122
f=1;
gotoxy(9,6);printf("FIBONACI FACTOREAL");
for(i=1;i<=m;i++)
{
f=f*i;
c=a+b;
a=b;
b=c;
gotoxy(15,8+i);printf("%d",c);
gotoxy(25,8+i);printf("%0.0f",f);
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;
}
}
void main()
{
do
{
IMPRIMIRA LOS MENSAJES QUE
DESEEMOS
REALIZARA OPERACIONES PARA
CALCULAR FIBONACI Y FACTOREAL
IMPRIMIRA LOS RESULTADOS DE
FIBONACI Y FACTOREAL
COMPRUEBA SI LA POSICION ES
PAR O IMPAR
PROGRAMA PRINCIPAL
CICLO DO WHILE ESTE
AYUDARA A REGRESAR AL
PROGRAMA CUANTAS VECES
123
clrscr();
borde();
gotoxy(30,2);printf("... SERIE CON VECTORES ...");
gotoxy(10,4);printf("LIMITE::> ");scanf("%d",&n);
serie(n);
gotoxy(15,22);printf("DESEA CONTINUAR DIJITE 1 CASO CONTRARIO 0 ==> ");scanf("%d",&op);
}while(op==1);
getch();
}
CORIDO DEL PROGRAMA
LLAMAMOS A LA FUNCION
DEL BORDE
INGRESAREMOS UN LMITE
CIERRE O FIN DEL
PROGRAMA
124
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>
#include<stdio.h>
int i, f, vect[100], vectbusq[100], lim, op;
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("Í");
gotoxy(i,24);cprintf("Í");
}
gotoxy(1,24);cprintf("È");gotoxy(80,24);cprintf("¼");
for(i=2;i<=23;i++)
{
Librerías principales
Variables Globales
Nuestro Borde
acompañado de una
Función.
125
textcolor(i);
gotoxy(1,i);cprintf("º");gotoxy(80,i);cprintf("º");
}
}
void busq(int l)
{
f=9;
for(i=1;i<=l;i++)
{
if(vect[i]%2==0)
{
gotoxy(34,f);printf("%d",vect[i]);
f=f+1;
}
}
f=9;
for(i=1;i<=l;i++)
{
if(vect[i]%2==1)
{
gotoxy(55,f);printf("%d",vect[i]);
f=f+1;
}
Función donde realizaremos el proceso del ejercicio
Abrimos llave para nuestra Función.
Igualación de variables
Este for nos indica el límite y
abrimos la llave del primer for.
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.
Cerramos la llave del primer for
Igualación de la variable
Este es un segundo for nos indica el
límite y abrimos llave para inicializar el for.
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.
126
}
}
void main()
{
do
{
clrscr();
bdob();
gotoxy(21,3);printf("<<BUSQUEDA DE # PARES E
IMPARES_VECTORES>>");
gotoxy(5,5);printf("Ingrese el limite>> ");scanf("%d",&lim);
gotoxy(13,7);printf("<<VECTOR>>");
gotoxy(26,7);printf("<<NUMEROS PARES>>");
gotoxy(47,7);printf("<<NUMEROS IMPARES>>");
f=9;
for(i=1;i<=lim;i++)
{
do
{
gotoxy(18,f);printf(" ");
gotoxy(18,f);scanf("%d",&vect[i]);
}
Comenzaremos con el programa
Abrimos la sentencia.
Limpiar pantalla.
Llamamos a la función borde.
Impresión de mensajes
Posición de fila
Este for nos indica el límite e abrimos
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.
Declaramos la posición de fila.
127
while(vect[i]<3 || vect[i]>33);
f=f+1;
}
busq(lim);
gotoxy(3,22);printf("Presione 1 para volver a ingresar vectores o 0 para
finalizar>> ");scanf("%d",&op);
}
while(op==1);
getch();
}
Corrido del Programa
Llamamos a la función
Imprimimos el mensaje
Aquí cerramos la llave del ciclo do while damos
pause a nuestro programa y cerramos llave.
128
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.
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();
Librerías
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
129
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
Ingreso de los
números pares
Ingreso de los impares,
repetición del proceso y fin
del programa
130
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> int i,conta,residuo,j,op,fila=5,k,aux,limite,vec[10]; void borde() { for(i=1;i<=79;i++) { gotoxy(i,1);printf("-"); gotoxy(i,23);printf("-"); } 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++) { do { gotoxy(5,fila);printf(" "); gotoxy(5,fila);scanf("%d",&vec[i]); } while((vec[i]<6)||(vec[i]>26)); fila=fila+1; } } void ascendente () { int fila=5; for (i=1;i<=limite;i++) { for (j=1;j<=limite;j++) { if (vec[i]<vec[j]) { aux=vec[i]; vec[i]=vec[j]; vec[j]=aux; } } } for (i=1;i<=limite;i++) { gotoxy(40,fila);printf("%d",vec[i]);
Proceso de borde
Inicio de la función para el
ingreso con un rango entre
6 y 26
Librerías, declaración de
variables he inicio de la
función borde
Inicio de función
ascendente calculamos
con dos for y una
condición Y para la
impresión un for mas para
el vector
131
fila=fila+1; } } void descendente () { int fila=5; for (i=1;i<=limite;i++) { for (j=1;j<=limite;j++) { if (vec[i]>vec[j]) { aux=vec[i]; vec[i]=vec[j]; vec[j]=aux; } } } for (i=1;i<=limite;i++) { 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(); }
Inicio de función
descendente calculamos
con dos for
Usamos una
condición Y para
la impresión un
for mas para el
vector
Inicio del
programa
principal
llamamos
funciones he
ingresamos el
limite
132
CORRIDO DEL PROGRAMA
133
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
#include<stdio.h>
#include<conio.h>
int op,i,j,limite,au,aux,mu,factor,fa,fila,vecto[15];
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("*");
Ingreso las
librerías
Declaración de
variables
Función borde
Este proceso es
para realizar el
borde
134
}
}
void facto()
{
fila=9;
mu=0;
au=1;
factor=1;
for(i=1;i<=limite;i++)
{
if(i%2==1)
{
mu=mu+fa;
vecto[i]=mu;
}
else
{
factor=factor*au;
au=au+1;
vecto[i]=factor;
}
gotoxy(7,fila);printf("%d",vecto[i]);
Función de la serie
Igualación de las
variables
Que el for vaya
hasta el límite
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
135
fila=fila+1;
}
}
void orden()
{
for(i=1;i<=limite;i++)
{
for(j=1;j<=limite;j++)
{
if(vecto[i]<vecto[j])
{
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++)
Ingresamos una
nueva función que se
llama orden
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]
136
{
for(j=1;j<=limite;j++)
{
if(vecto[i]>vecto[j])
{
aux=vecto[i];
vecto[i]=vecto[j];
vecto[j]=aux;
}
}
}
fila=9;
for(i=1;i<=limite;i++)
{
gotoxy(35,fila);printf("%d",vecto[i]);
fila=fila+1;
}
}
void main()
{
do
{
clrscr();
borde();
gotoxy(25,3);printf("FacPares/Impares");
Abro el programa
Abro el do
Llama a la función
de borde
Limpio de pantalla
Posición en donde
que quiero que se
me imprima printf
Llama a la función
de borde
Limpio de pantalla
Posición en donde
que quiero que se
me imprima printf
Pide el límite que
quieres imprimir
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]
Después vamos a
mandar otro for que
vaya hasta el límite y
después vamos a
imprimir el vector [i]
137
gotoxy(12,5);printf("Ingrese el limite: ");scanf("%d",&limite);
gotoxy(10,7);printf("Factor: ");scanf("%d",&fa);
facto();
orden();
gotoxy(5,20);printf("Presione 1 para repetir el proceso o 0 para salir: ");scanf("%d",&op);
}
while(op==1);
getch();
}
Pide el factor que
quieres imprimir
Se me imprime
mensaje para
continuar o terminar
el programa
Llamo a la función
facto
Cierro la función de
do-while
Llamo a la función
orden
Cierro el programa
138
CORRIDO DEL PROGRAMA
139
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>
#include<stdio.h>
int f1, aux, num, i, j, f, vect[100];
int vectser[100], lim, op, cont;
void borde()
Ingresamos las librerías que vamos a utilizar
Ingresamos las variables que vamos a utilizar, son variable
de tipo enteras
140
{
int i;
clrscr();
gotoxy(1,1);printf("É");
gotoxy(80,1);printf("»");
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("º");
}}
void primo(int l)
{
f=9;
f1=9;
for(j=1;j<=l;j++)
{
do
{
gotoxy(18,f);printf(" ");
gotoxy(18,f);scanf("%d",&vect[j]);
Aquí realizamos una función para
poder realizar el borde en el programa
Aquí realizamos una función para
poder verificar si un número es o no
Aquí imprimimos y validamos el vector ingresado que este
entre parámetro que nos dieron para realizarlo
141
}
while(vect[j]<3 || vect[j]>25);
f=f+1;
cont=0;
for(i=1;i<=vect[j];i++)
{
if(vect[j]%i==0)
{
cont=cont+1;
}}
if(cont==2)
{
vectser[j]=vect[j];
gotoxy(34,f1);printf("%d",vectser[j]);
f1=f1+1;
}}}
void orden(int l)
{
for(i=1;i<=l;i++)
{
for(j=1;j<=l;j++)
{
if(vectser[i]<vectser[j])
{
aux=vectser[i];
vectser[i]=vectser[j];
vectser[j]=aux;
Esta función es para poder ordenar al vector de manera ascendente y
descendente
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
Aquí utilizamos una variable auxiliar
para que tome el valor de otra variable
Sumamos a la fila (f=f+1), y igualamos a cero el
Este for es para que se imprima en las filas pares
Este if es para que se imprima en las filas impares
142
}}}
gotoxy(29,9);printf("ASCE");
f=11;
for(i=1;i<=l;i++)
{
gotoxy(39,f);printf("%d",vectser[i]);
f=f+1;
}
for(i=1;i<=l;i++)
{
for(j=1;j<=l;j++)
{
if(vectser[i]>vectser[j])
{
aux=vectser[i];
vectser[i]=vectser[j];
vectser[j]=aux;
}}}
gotoxy(52,9);printf("DESC");
f=11;
for(i=1;i<=l;i++)
{
gotoxy(62,f);printf("%d",vectser[i]);
f=f+1;
}}
void main()
{
Igualamos la fila a
11
Imprimimos al vector de manera ascendente
Estos for son para que se
imprima hasta un cierto límite.
Aquí utilizamos una variable auxiliar
para que tome el valor de otra variable
Imprimimos al vector de manera descendente
Realizamos el programa principal
143
do
{
clrscr();
borde();
gotoxy(21,3);printf("BUSQUEDA DE NUMRS- PARES E IMPARES");
gotoxy(5,5);printf("limite: ");scanf("%d",&lim);
gotoxy(13,7);printf("VECTOR");
gotoxy(26,7);printf("#PRIMOS");
gotoxy(47,7);printf("#IMPARES");
primo(lim);
orden(lim);
gotoxy(3,22);printf("Otra vez si1/no 0: ");scanf("%d",&op);
}
while(op==1);
getch();
}
Ponemos una sentencia do-while para que se pueda repetir n veces.
Ingresamos el
límite e
imprimimos un
título
Llamamos a las demás funciones que ya realizamos.
Cerramos el lazo do-while
Terminamos con un getch(); y con la
144
CORRIDO DEL PROGRAMA
145
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>
#include<string.h>
#include<ctype.h>
char cadena[20],vecimpar[20];
int i,fi,op,n,h;
void borde()
{
Librerías
Declaracion de variables tipo caracter
Inicio función borde
Declaracion de variables enteras
146
for (i=1;i<=80;i++)
{
textcolor(i+1);
gotoxy(i,1);cprintf("*");
gotoxy(i,24);cprintf("*");
}
for (i=1;i<=24;i++)
{
textcolor(i+1);
gotoxy(1,i);cprintf("*");
gotoxy(80,i);cprintf("*");
}
}
void cad()
{
flushall();
gotoxy(30,5);gets(cadena);
l=strlen(cadena);
fila=9;
for(i=0;i<l;i++)
{
textcolor(i+1);
gotoxy(23,fi);cprintf("%c",cadena[i]);
fila=fila+1;
}
Inicio función cad
Fin función borde
Fin ciclo for
Impresión borde
color
Inicio ciclo for
color
Impresión borde
Fin ciclo for
Inicio ciclo for
Palabra reservada que permite funcionar ciclo do while
Impresión cadena
Igualación limite palabra reservada strlen
Igualación fila a 9
Inicio ciclo for
Impresión vector ingresante
Contador mas 1
Fin ciclo for
color
Fin función cadena
147
}
void cont()
{
h=1;
for(i=0;i<n;i++)
{
vecimpar[h]=cadena[i];
h=h+1;
}
fila=8;
for(i=0;i<h;i++)
{
gotoxy(45,fi);printf("%c",vecimpar[i]);
fila=fila+1;
}
}
void main()
{
do
{
clrscr();
borde();
gotoxy(25,3);printf("<< CARACTERES >>");
gotoxy(8,5);printf("*.CARACTERES : ");
gotoxy(15,7);printf("<< V REALIZADO>>");
Inicio función cont
Igualación variable a 1
Inicio ciclo for
Igualación vector auxiliar a vector ingresante
Contador mas 1
Fin ciclo for
Igualación variable fila a 8
Inicio ciclo for
Impresión vector resultante
Contador mas 1
Fin ciclo for
Fin funcion cad
Inicio función principal
Inicio ciclo do while
Blanqueo de pantalla
Se llama a la funcion borde
Impresión titulos
148
gotoxy(38,7);printf("<< V.RESULTANTE>>");
cad();
cont();
gotoxy(12,22);printf("PULSE 1 PARA CONTINUAR O 0 PARA SALIR :
");scanf("%d",&op);
}
while(op==1);
getch();
}
CORRIDO DEL PROGRAMA
Se llama a la funcion cad
Se llama a la función cont
Impresión
repetición
Fin ciclo do while
Fin programa
149
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); gotoxy(i,1);cprintf("*"); gotoxy(i,24);cprintf("*"); } for(i=2;i<=23;i++) { textcolor(17);
Abrimos las librerías
Iniciamos los valores de nuestro programa
Nuestro borde
150
gotoxy(1,i);cprintf("*"); gotoxy(80,i);cprintf("*"); } } void nomb() { flushall(); gotoxy(12,5);gets(nombre); n=strlen(nombre); fi=5; for(i=0;i<n;i++) { if(islower (nombre[i])) { nombre[i]=toupper(nombre[i]); textcolor(i+1); 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); }} } void main() { do { clrscr(); borde(); nomb(); textcolor(2); gotoxy(12,18);cprintf("ingrese el caracter ");scanf("%c",&a); textcolor(3); for(i=0;i<n;i++) { if(nombre[i]==a) { 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);
Función que ocuparemos
después
Permite leer el carácter
Permite almacenar en otro vector
For para ingresar el vector,
utilizamos la función textcolor para
poner color a las letras
Comenzaremos con el
programa principal
Abrimos la Sentencia do
Borrado de pantalla y llamado de la función
borde Llamamos a las funciones
Cerramos la sentencia do
while
Imprimir el título y subtítulos
de nuestro programa
For para su limite y el if para buscar
su posición par
151
getch(); }
CORRIDO DEL PROGRAMA:
Pausado en el programa y
cerrado del programa
152
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 #include<stdio.h> #include<conio.h> #include<string.h> #include<ctype.h> char nombre[20],vecimpar[20]; int i,fi,op,n,h; void borde() { for(i=1;i<=79;i++) { textcolor(9); gotoxy(i,1);printf("±"); gotoxy(i,24);printf("±"); } for(i=2;i<=23;i++) { textcolor(9); gotoxy(1,i);printf("±"); gotoxy(80,i);printf("±"); } } void nomb() { flushall(); textcolor(3); gotoxy(5,5);cprintf("TEXTO:"); textcolor(i+1); gotoxy(12,5);gets(nombre); n=strlen(nombre);
Librerías.- colección de clases y funciones, escritas en el núcleo del lenguaje.
Variables.- son un tipo de dato
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.
Lectura de variables
Sentencia “for” para realizar el borde
Alfabéticas Enteras
Color para el texto
Impresión del vector
153
fi=9; for(i=0;i<n;i++) { textcolor(3); gotoxy(5,7);cprintf("VECTOR"); textcolor(i+1); gotoxy(8,fi);cprintf("%c",nombre[i]); fi=fi+1; } } void impar() { h=1; for(i=0;i<n;i++) { if(i%2==0) { vecimpar[h]=nombre[i]; h=h+1; } } fi=8; for(i=0;i<h;i++) { textcolor(3); gotoxy(15,7);cprintf("POSICIONES"); textcolor(i+1); gotoxy(20,fi);cprintf("%c",vecimpar[i]); fi=fi+1; } } void main() { do { clrscr(); borde(); textcolor(2); gotoxy(15,3);cprintf("VECTORES"); nomb(); impar(); gotoxy(5,22);cprintf("Desea repetir 1 Salir 0: ");scanf("%d",&op); }while(op==1); getch(); }
Un vector, también llamado array(arreglo) unidimensional, es una estructura de datos que permite agrupar elementos del mismo tipo y almacenarlos en un solo bloque de memoria juntos, uno después de otro. A este grupo de elementos se les identifica por un mismo nombre y la posición en la que se encuentran. La primera posición del array es la posición 0.
Sentencia “for” para la impresión de las letras en posiciones impares
Color para el texto
Inicio del programa Sentencia do while
Proceso de repeticiónBorrar pantalla Funcion borde
Funciones
Pausa Fin del programa
154
CORRIDO DEL PROGRAMA
155
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
#include<stdio.h> #include<conio.h> #include<string.h> char nombre[20],vecimpar[20]; int i,fi,op,n,h,j,aux,col; void borde() { for(i=1;i<=80;i++) { textcolor(5); gotoxy(i,1);cprintf("±"); gotoxy(i,24);cprintf("±"); } textcolor(5); for(i=2;i<=24;i++) { gotoxy(1,i);cprintf("±"); gotoxy(80,i);cprintf("±"); } } void nomb() { flushall(); textcolor(2); gotoxy(5,5);cprintf("TEXTO"); gotoxy(12,5);gets(nombre); n=strlen(nombre); fi=8;
Librerías.- colección de clases y funciones, escritas en el núcleo del lenguaje.
Variables.- son un tipo de dato
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.
Lectura de variables
Sentencia “for” para realizar el borde
Alfabéticas Enteras
Color para el texto
Impresión del vector
156
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; for(i=n;i>=0;i--) { textcolor(2); gotoxy(15,7);cprintf("INVERTIDO"); textcolor(i+1); gotoxy(20,fi);cprintf("%c",nombre[i]); fi=fi+1; } } void main() { do { clrscr(); borde(); textcolor(5); gotoxy(15,3);cprintf("VECTORES"); nomb(); textcolor(5); gotoxy(5,22);cprintf("Desea repetir 1 Salir 0: ");scanf("%d",&op); }while(op==1); getch(); }
Sentencia “for” para la impresión DE LA FRASE
INVERTIDA
Inicio del programa
Sentencia do while
Proceso de repeticiónBorrar pantalla Funcion borde
Funciones
Pausa Fin del programa
157
CORRIDO DEL PROGRAMA
158
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>
#include<conio.h>
int i,op,fila,a;
char nom[40];
void borde()
{
for(i=1;i<=80;i++)
{
textcolor(i+1);
gotoxy(i,1);printf("!");
gotoxy(i,24);printf("!");
}
for(i=2;i<=24;i++)
{
textcolor(i+1);
gotoxy(1,i);printf("!");
gotoxy(80,i);printf("!");
}
}
void inver()
Librerías
Declaración de variables
Función global para el borde, e inicio
del ciclo, da color
Impresión del borde, cierre del ciclo
Función global para el borde, e inicio
del ciclo, da color
Impresión del borde
Cierre del ciclo y de la
función
Función global e inicio
159
{
flushall();
gotoxy(20,6);printf("Ingrese la palabra: ");gets(nom);
a=strlen(nom);
fila=9;
for(i=0;i<a;i++)
{
textcolor(i+1);
gotoxy(30,fila);cprintf("%c",nom[i]);
fila=fila+1;
}
fila=8;
for(i=a;i>=0;i--)
{
textcolor(i+1);
gotoxy(45,fila);cprintf("%c",nom[i]);
fila=fila+1;
}
}
void main()
{
do
{
clrscr();
borde();
gotoxy(32,2);printf("**Cadena de Caracteres Invertida**");
gotoxy(27,8);printf("Vector");
gotoxy(43,8);printf("Inversion");
inver();
Ingreso de datos con caracteres y
almacenarían en auxiliar
Ciclo “FOR” ,color para e vector
Impresión del vector en forma
vertical
Proceso de la forma
invertida con ciclo “for”
Impresión del nuevo vector
invertido y con color
Cierre del ciclo y de la
función
Función principal e inicio
Inicio del ciclo “do-while”
Limpiado de pantalla y
llamado de la función borde
Impresión de mensajes
Llamado de la función
global
160
gotoxy(12,22);printf("Digite 1 para continuar o 0 para salir : ");scanf("%d",&op);
}while(op==1);
getch();
}
CORRIDO DEL PROGRAMA:
Cierre del ciclo
Pausa y cierre del
programa
161
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>
#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);
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()
{
gotoxy(5,5);printf("Cadena:");gets(cad); //IMPRIMO UN MENSAJE CON LA PALABRA CADENA\\
FUNCIÓN BORDE
FUNCION PARA SACAR CONSONANTES
LIBRERIAS
162
lim=strlen(cad);
li=7;// ACUMULADOR \\
p=0;//CONTADOR\\
for(i=0;i<lim;i++) // CICLO FOR PARA SACAR EL LIMITE DE LETRAS QUE QUIERO ENCONTRAR\\
{ // ABRO EL CICLO FOR\\
gotoxy(25,li);printf("%c\n",cad[i]); //IMPRIMO LA CANTIDAD DE LETRAS\\
li=li+1; //CONTADOR DEL CICLO FOR QUE SE BA IR SUMANDO DE UNO EN UNO\\
x=i; // AUXILIAR\\
(cad[i]);
if (x != 0)
{
if((cad[i] == 'a')||(cad[i] == 'e')||(cad[i] == 'i')||(cad[i] == 'o')||(cad[i] == 'u')) // CONDICIONES PARA ENCONTRAR
LAS C
ONSONANTES\\
{
}
Else // CASO CONTRARIO\\
{
c2[p]=cad[i];
p=p+1; // SIRVE PARA I R DE UNO EN UNO SUMANDO \\
}
}
}
li=7; // CONTADOR \\
lim=lim-1; //LIMITE MENOS1 \\
for(i=0;i<p;i++) //
{
gotoxy(45,li);printf("%c",c2[i]);//IMPRIMO CARACTER\\
li=li+1;//LIMITE MAS UNO\\
}
}
void main() // FUNCION PRINCIPAL\\
163
{ // 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
164
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
#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("*"); } }
Librerías
Declaración de Variables int
Inicio de función borde
Lazo For
Fin de función
165
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; }}}
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
166
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() {
Función Ascendente
Lazo For
Fin de función
Función descendente
Lazo for
Fin de función
Función principal
167
do { clrscr(); borde(); ingreso(); primos(); ascendente(); descendente(); getch(); gotoxy(10,22);printf("Presione 1/0>> ");scanf("%d",&op); }while(op==1); }
CORRIDO DEL PROGRAMA
Llamado de funciones
Lazo Do While
Fin de función
168
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> #include<conio.h> int j,i,k,op,matriz1[10][10],col=10,fila=8,limite,datos,sali,f; void borde() { for(k=2;k<=80;k++) { gotoxy(k,2);printf("-"); gotoxy(k,24);printf("-"); } 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++) { for(j=1;j<=limite;j++) { gotoxy(col,fila); scanf("%d",&matriz1[i][j]); col=col+5; } col=10; fila=fila+1; } } void sal(int sali) { fila=8; col=40; for(i=1;i<=limite; i++) { for(j=1;j<=limite;j++)
Librerías
Declaración de variables
Función para el diseño del borde
Función para el ingreso de los
datos de la matriz utilizando
ciclos FOR
Función para la impresión de
nuestra matriz utilizando ciclos
FOR
169
{ gotoxy(col,fila); printf("%d",matriz1[i][j]); col=col+5; } col=40; fila=fila+1; } } void main() { do { clrscr(); borde(); gotoxy(3,3); printf("Ingrese un límite: "); scanf("%d",&limite); ing(datos); sal(sali);
gotoxy(4,22); printf("NUEVO 1 SALIR 0: "); scanf("%d",&op); } while(op==1); getch(); }
CORRIDO DEL PROGRAMA
Cuerpo principal del programa
Ciclo DO-while para repetir n veces
Blanqueo de pantalla
Llamado de la función del borde
Llamado de las funciones de la matriz
Ingreso del límite de datos
Ciclo DO-while para repetir n
veces
Pausar pantalla
170
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); ENUNCIADOS gotoxy(8,6);cprintf("Factor: ");scanf("%d",&factor);
171
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
172
CORRIDO DEL PROGRAMA
173
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;
174
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
175
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>
#include<stdio.h>
int fil, col, aux, i, j, mat[10][10], vect[10], lim, op, a, b, c, h;
void bdob()
{
int i;
clrscr();
gotoxy(1,1);printf("É");
gotoxy(80,1);printf("»");
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++)
{
Declaración de variables
Librerías
Función global para el
borde
176
gotoxy(1,i);printf("º");
gotoxy(80,i);printf("º");
}
}
void diag()
{
col=5;
fil=8;
a=1;
b=0;
c=0;
for(i=1;i<=lim;i++)
{
for(j=1;j<=lim;j++)
{
c=a+b;
a=b;
b=c;
mat[i][j]=c;
gotoxy(col,fil);printf("%d",mat[i][j]);
col=col+4;
}
col=5;
fil=fil+3;
}
}
Inicio de la función para
determinar las diagonales
Condición para calcular las
diagonales
Proceso para calcular la
serie del fibonasi
177
void dprinc()
{
col=21;
fil=8;
h=1;
for(i=1;i<=lim;i++)
{
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]);
col=col+4;
}
}
fil=fil+3;
}
}
void dsec()
{
col=28;
fil=8;
j=lim;
for(i=1;i<=lim;i++)
Inicio de la función calcular
la diagonal principal
Condición para calcular la
diagonal
Imprimimos la matriz
Función para calcular la
diagonal secundaria
178
{
vect[h]=mat[i][j];
h=h+1;
gotoxy(col,fil);printf("%d",mat[i][j]);
j=j-1;
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()
{
fil=8;
for(i=1;i<h;i++)
{
for(j=1;j<h;j++)
{
if(vect[i]<vect[j])
{
Imprimimos la matriz
Función para ordenar las
diagonales.
179
aux=vect[i];
vect[i]=vect[j];
vect[j]=aux;
}
}
}
fil=8;
for(i=1;i<h;i++)
{
gotoxy(56,fil);printf("%d",vect[i]);
fil=fil+2;
}
for(i=1;i<h;i++)
{
for(j=1;j<h;j++)
{
if(vect[i]>vect[j])
{
aux=vect[i];
vect[i]=vect[j];
vect[j]=aux;
}
}
}
fil=8;
for(i=1;i<h;i++)
{
Calculamos el vector
descendente
Proceso para ordenar
Calculamos el vector
ascendente
180
gotoxy(71,fil);printf("%d",vect[i]);
fil=fil+2;
}
}
void main()
{
do
{
clrscr();
bdob();
gotoxy(34,2);printf("<<MATRICES>>");
gotoxy(5,4);printf("Ingrese el limite>> ");scanf("%d",&lim);
gotoxy(4,6);printf("<<MATRIZ>>");
gotoxy(18,6);printf("<<Diagonales>>");
gotoxy(34,6);printf("<<Vector_Diag>>");
gotoxy(50,6);printf("<<Ascendente>>");
gotoxy(65,6);printf("<<Descendente>>");
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();
}
Función donde a
proseguimos a imprimir
los datos
Pedimos los respectivos
datos.
181
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