libro digital de programación

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:


#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:


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


break;


}

}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 */


}

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;


intercambio(&a,&b); /* llamada */


}

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][3]=8


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;



};

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


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


LECTURA DE

VARIABLES

CONDICIONAL “IF”

FIN

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


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


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


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


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


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

60


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


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("*");


}

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

{

gotoxy(1,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


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


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


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.


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


Programa Nº15

Diseñe un programa en c++ que me permita visualizar los números primos con repetición y el borde.



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

FIN

72


Programa Nº16

Diseñe un programa que me permita generar cualquier seria de números.


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


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.



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


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


Programa Nº19ç

Generar n elementos de la siguiente serie, cualquier factor ingresando

desde teclado como numerador, el denominador números pares.



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


Programa Nº20

Genere una serie de datos que lleve por numerador el factorial y por

denominador la serie de Fibonacci



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


Programa Nº21

Genere la siguiente serie de datos primos en el numerador e impares en

el denominador.


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


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


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


Programa Nº24



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


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.



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


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

{


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

}


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

{



}

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

{



}

}

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


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(4,22);printf("PRESIONE 1 PARA VOLVER AL MENU O 0 PARA

SALIR: ");scanf("%d",&op);

}

while(op==1);

getch();

}


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


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("*");


}

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

{

gotoxy(1,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

107


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

{



}

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

{



}

}

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;


{

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.



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




110


{

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;


{

multivec[i]=vector1[i]*vector2[i];

gotoxy(40,fila); printf("%d",multivec[i]);

fila=fila+1;

}

}

void division(limite1)

{

fila=8;


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






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.




111


{

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


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.


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(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(40,7); printf("RESTA VECTOR");



ingreso(limite1);

resta(limite1);

gotoxy(10,23); printf("SI DESEA REPETIR

EL PROCESO PRESIONE 1 CASO CONTRARIO 0==>");

scanf("%d",&opc);

}

while(opc==1);

break;

case 3:

do

{

clrscr();

borde();

gotoxy(30,3); printf("3.-MULTIPLICACION");



gotoxy(40,7); printf("MULTIPLICACION VECTOR");



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








114

scanf("%d",&opc);

}

while(opc==1);

break;

do

{

case 4:

clrscr();

borde();

gotoxy(30,3); printf("4.-DIVISION");



gotoxy(40,7); printf("DIVISION VECTOR");



ingreso(limite1);

division(limite1);

gotoxy(10,23); printf("SI DESEA REPETIR

EL PROCESO PRESIONE 1 CASO CONTRARIO 0==>");

scanf("%d",&opc);

}

while(opc==1);

break;

}

clrscr();

borde();

gotoxy(10,23);

printf("SI DESEA VOLVER AL MENU PRESIONE 1 CASO CONTRARIO

O==>");

scanf("%d",&op);

}

Diseño de la cuarta








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.

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("*");


for(i=2;i<=79;i++)

{



}



for(i=2;i<=23;i++)

{



}

}

Activación de librería esto habilita

procesos para el programa


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

}


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

{





}

for(i=2;i<=23;i++)

{





}

}

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


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


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


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

{



}

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

{



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(j=1;j<=limite;j++)

{

if(vecto[i]<vecto[j])

{

aux=vecto[i];

vecto[i]=vecto[j];

vecto[j]=aux;

}

}

}

fila=9;


{


fila=fila+1;

}

fila=9;


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;


{


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


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(1,24);printf("È");

gotoxy(80,24);printf("¼");

for(i=2;i<=23;i++)

{

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


}}

void primo(int l)

{

f=9;

f1=9;

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

{

do

{


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


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



}

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

{

textcolor(i+1);



}

}

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

}


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


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


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


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

{



}

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

{

gotoxy(1,i);cprintf("*"); //IMPRECION DE *\\


} //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\\


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


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


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


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


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


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(1,24);printf("È");

gotoxy(80,24);printf("¼");

for(i=2;i<=23;i++)

{


Librerías

Función global para el

borde

176



}

}

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;


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;


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

{


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


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


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

libro digital de programación

Education