Libro digital de programación

3,927 views
3,730 views

Published on

Published in: Education
1 Comment
4 Likes
Statistics
Notes
No Downloads
Views
Total views
3,927
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
486
Comments
1
Likes
4
Embeds 0
No embeds

No notes for slide

Libro digital de programación

  1. 1. 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. 2. INDICE Tabla de contenido ¿Qué es el Turbo C++? .................................................................................................................4 CARACTERÍSTICAS ................................................................................................................1 ELEMENTOS BÁSICOS DEL LENGUAJE C ........................................................................2 ESTRUCTURA ..........................................................................................................................4 COMENTARIOS ........................................................................................................................5 IDENTIFICADORES .................................................................................................................6 TIPOS DE DATOS ....................................................................................................................6 SALIDA / ENTRADA ...............................................................................................................11 SENTENCIAS CONDICIONALES ........................................................................................14  Estructura IF...ELSE ..................................................................................................14  Estructura SWITCH ...................................................................................................15 BUCLES ...................................................................................................................................16  Sentencia WHILE .......................................................................................................16 Sentencia DO...WHILE .......................................................................................................17 Sentencia FOR ....................................................................................................................18 Sentencia BREAK ...............................................................................................................19 Sentencia CONTINUE ........................................................................................................19 FUNCIONES ............................................................................................................................20  Funciones ....................................................................................................................21 VECTORES..............................................................................................................................25 MATRICES ...............................................................................................................................28 LIBRERÍAS...............................................................................................................................33 Librería stdio.h .....................................................................................................................33 Librería stdlib.h ....................................................................................................................34 Librería conio.h ....................................................................................................................34 Librería string.h ....................................................................................................................35 BIBLIOGRAFIA ........................................................................................................................95 2
  3. 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. 3
  4. 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. 4
  5. 5. CARACTERÍSTICAS  El lenguaje C se conoce como un lenguaje compilado. Existen dos tipos de lenguaje: interpretados y compilados. Los interpretados son aquellos que necesitan del código fuente para funcionar. Ejemplo: Basic. Los compilados convierten el código fuente en un fichero objeto y éste en un fichero ejecutable.  Podemos decir que el lenguaje C es un lenguaje de nivel medio, ya que combina elementos de lenguaje de alto nivel con la funcionalidad del lenguaje ensamblador. Es un lenguaje estructurado, ya que permite crear procedimientos en bloques dentro de otros procedimientos. Hay que destacar que el C es un lenguaje portable, ya que permite utilizar el mismo código en diferentes equipos y sistemas informáticos: el lenguaje es independiente de la arquitectura de cualquier máquina en particular.  Por último solo queda decir que el C es un lenguaje relativamente pequeño; se puede describir en poco espacio y aprender rápidamente. 1
  6. 6. ELEMENTOS BÁSICOS DEL LENGUAJE C Un programa en C++ está definido por funciones, grupo de instrucciones que pueden o no hacer algún cálculo, donde la función principal debe ser llamada main. La composición general de un programa en C++ es: Directivas de pre procesamiento Declaración global Función main Funciones definidas po Comentarios para entender el funcionamiento del programar el usuario 2
  7. 7.  Directivas Las directivas de pre procesamiento son definidas para que el compilador realice algo antes de compilar el programa, revisar si la sintaxis es correcta y generar un código ejecutable por la computadora, como el incluir funciones de alguna biblioteca conocida. La directiva para incluir bibliotecas es como las siguientes: Ejemplo: #include <iostream.h> Esta directiva permitirá utilizar la función de lectura cin y la función de escritura cout propias de C++. #include <stdio.h> Esta directiva permitirá utilizar las funciones de lectura y escritura propias de C.  Declaraciones Globales Las declaraciones globales son definiciones de variables o constantes que serán utilizadas por cualquiera de todas las funciones definidas en el programa. La sintaxis para la declaración de una variable es: Tipo var1, var2,..., var3; o bien Tipo var1= valor, var2,..., var3;  Función main La función main( ), es obligatoria en cada programa C, C++. Indica el comienzo del programa y requiere los paréntesis ( ) a continuación de main( ).  Funciones definidas por el usuario La definición de una función se realiza escribiendo primero el tipo del valor de retorno de la función, después el nombre de la función, posteriormente entre paréntesis las variables que utilizará dicha función, parámetros, y finalmente las instrucciones de la función. 3
  8. 8. Ejemplo: double promedio ( int a, int b, int c) { return (a + b + c ) / 3.0; } Declara a la función promedio, la cual recibe tres valores enteros y calcula y regresa el promedio de ellos.  Comentarios Los comentarios pueden escribirse utilizando alguna de las siguientes formas: comentando en la misma línea, utiliza //, Ejemplo: int edad; // la edad se utilizará como un valor entero. Comentando entre varias líneas, utiliza /* */, ESTRUCTURA Todo programa en C consta de una o más funciones, una de las cuales se llama main. El programa comienza en la función main, desde la cual es posible llamar a otras funciones. Cada función estará formada por la cabecera de la función, compuesta por el nombre de la misma y la lista de argumentos, la declaración de las variables a utilizar y la secuencia de sentencias a ejecutar. Ejemplo: declaraciones globales main( ) { variables locales bloque } funcion1( ) { variables locales bloque } 4
  9. 9. COMENTARIOS A la hora de programar es conveniente añadir comentarios para poder saber que función tiene cada parte del código, en caso de que no lo utilicemos durante algún tiempo. Además facilitaremos el trabajo a otros programadores que puedan utilizar nuestro archivo fuente. Para poner comentarios en un programa escrito en C usamos los símbolos /*y */: /* Este es un ejemplo de comentario */ /* Un comentario también puede Estar escrito en varias líneas */ El símbolo /* se coloca al principio del comentario y el símbolo */ al final. El comentario, contenido entre estos dos símbolos, no será tenido en cuenta por el compilador. Palabras clave Existen una serie de indicadores reservados, con una finalidad determinada, que no podemos utilizar como identificadores. A continuación vemos algunas de estas palabras clave: char int float double if else do while short long extern static default break sizeof continue for register typedef 5 switch
  10. 10. IDENTIFICADORES Un identificador es el nombre que damos a las variables y funciones. Está formado por una secuencia de letras y dígitos, aunque también acepta el carácter de subrayado. Por contra no acepta los acentos ni la ñ/Ñ. El primer carácter de un identificador no puede ser un número, es decir que debe ser una letra o el símbolo. Se diferencian las mayúsculas de las minúsculas, así num, Num y nuM son distintos identificadores. TIPOS DE DATOS  Enteros Dentro de los enteros están los tipos: short, int, long, los cuales varían en rango de acuerdo al compilador que se utilice, siendo long rango mayor y short el de menor.  Flotantes Dentro de los flotantes C++ tiene los tipos: float, double y long double donde al igual que los enteros varía el rango de cada uno de acuerdo al compilador que se utilice. De igual forma el float es el de menor rango siendo long double el de rango mayor.  Caracteres Se utiliza el tipo char. Para representar un carácter en C++ se utilizan apóstrofes. Ejemplos: „a‟, „b‟ , „5‟ Para representar una cadena de caracteres se utilizan las comillas. Ejemplo: “soy una cadena” 6
  11. 11. TIPO char int float double Tamaño 1 byte 2 bytes 4 bytes 8 bytes Rango de valores -128 a 127 -32768 a 32767 3'4 E-38 a 3'4 E+38 1'7 E-308 a 1'7 E+308 Calificadores de tipo Los calificadores de tipo tienen la misión de modificar el rango de valores de un determinado tipo de variable. Estos calificadores son cuatro:  signed Le indica a la variable que va a llevar signo. Es el utilizado por defecto. Tamaño signed char 1 byte signed int 2 bytes Rango de valores -128 a 127 -32768 a 32767  unsigned Le indica a la variable que no va a llevar signo (valor absoluto). Tamaño unsigned char 1 byte unsigned int 2 bytes rango de valores 0 a 255 0 a 65535  short Rango de valores en formato corto (limitado). Es el utilizado por defecto. Tamaño short char short int 1 byte 2 bytes rango de valores -128 a 127 -32768 a 32767  long Rango de valores en formato largo (ampliado). Tamaño long int 4 bytes long double 10 bytes rango de valores -2.147.483.648 a 2.147.483.647 -3'36 E-4932 a 1'18 E+4932 También es posible combinar calificadores entre sí: signed long int = long int = long unsigned long int = unsigned long 4 bytes 0 a 4.294.967.295 El mayor entero permitido en 'C' 7
  12. 12. Las variables Una variable es un tipo de dato, referenciado mediante un identificador llamado de la variable. Su contenido podrá ser modificado a lo largo del programa. Una variable sólo puede pertenecer a un tipo de dato. Para poder utilizar una variable, primero tiene que ser declarada: [calificador] <tipo> <nombre> Es posible inicializar y declarar más de una variable del mismo tipo en la misma sentencia: [calificador]<tipo><nombre1>,<nombre2>=<valor>,<nombre3>=<valor>,<no mbre4> Ejemplo: /* Uso de las variables */ #include <stdio.h> main() /* Suma dos valores */ { int num1=4,num2,num3=6; printf("El valor de num1 es %d",num1); printf("nEl valor de num3 es %d",num3); num2=num1+num3; printf("nnum1 + num3 = %d",num2); } ¿Dónde se declaran? Las variables pueden ser de dos tipos según el lugar en que las declaremos: globales o locales. La variable global se declara antes de la main( ). Puede ser utilizada en cualquier parte del programa y se destruye al finalizar éste. 8
  13. 13. La variable local se declara después de la main( ), en la función en que vaya a ser utilizada. Sólo existe dentro de la función en que se declara y se destruye al finalizar dicha función. El identificador, nombre de la variable, no puede ser una palabra clave y los caracteres que podemos utilizar son las letras: a-z y A-Z, la ñ o Ñ no está permitida, los números: 0-9 y el símbolo de subrayado. Además hay que tener en cuenta que el primer carácter no puede ser un número. Ejemplo: /* Declaración de variables */ #include <stdio.h> int a; main() /* Muestra dos valores */ { int b=4; printf("b es local y vale %d",b); a=5; printf("na es global y vale %d",a); } Constantes Al contrario que las variables, las constantes mantienen su valor a lo largo de todo el programa. Para indicar al compilador que se trata de una constante, usaremos la directiva #define: #define <identificador> <valor> Observa que no se indica el punto y coma de final de sentencia ni tampoco el tipo de dato. La directiva #define no sólo nos permite sustituir un nombre por un valor numérico, sino también por una cadena de caracteres. El valor de una constante no puede ser modificado de ninguna manera. Ejemplo: /* Uso de las constantes */ #include <stdio.h> #define pi 3.1416 9
  14. 14. #define escribe printf main() /* Calcula el perímetro */ { int r; escribe("Introduce el radio: "); scanf("%d",&r); escribe("El perímetro es: %f",2*pi*r); } Secuencias de escape Ciertos caracteres no representados gráficamente se pueden representar mediante lo que se conoce como secuencia de escape. A continuación vemos una tabla de las más significativas: n salto de línea b retroceso t tabulación horizontal v tabulación vertical contrabarra f salto de página ' apóstrofe " comillas dobles 0 fin de una cadena de caracteres Ejemplo: /* Uso de las secuencias de escape */ #include <stdio.h> main() /* Escribe diversas sec. de escape */ { printf("Me llamo "Nemo" el grande"); 10
  15. 15. printf("nDirección: C Mayor 25"); printf("nHa salido la letra 'L'"); printf("nRetrocesob"); printf("ntEsto ha sido todo"); } Inclusión de ficheros En la programación en C es posible utilizar funciones que no estén incluidas en el propio programa. Para ello utilizamos la directiva #include, que nos permite añadir librerías o funciones que se encuentran en otros ficheros a nuestro programa. Para indicar al compilador que vamos a incluir ficheros externos podemos hacerlo de dos maneras, siempre antes de las declaraciones. 1. Indicándole al compilador la ruta donde se encuentra el fichero. #include "misfunc.h" #include "c:includesmisfunc.h" 2. Indicando que se encuentran en el directorio por defecto del compilador. #include <misfunc.h> SALIDA / ENTRADA  Sentencia printf( ) La rutina printf permite la aparición de valores numéricos, caracteres y cadenas de texto por pantalla. El prototipo de la sentencia printf es el siguiente: printf(control,arg1,arg2...); En la cadena de control indicamos la forma en que se mostrarán los argumentos posteriores. También podemos introducir una cadena de texto, sin necesidad de argumentos, o combinar ambas posibilidades, así como secuencias de escape. 11
  16. 16. En el caso de que utilicemos argumentos deberemos indicar en la cadena de control tantos modificadores como argumentos vayamos a presentar. El modificador está compuesto por el carácter % seguido por un carácter de conversión, que indica de qué tipo de dato se trata. Ejemplo: /* Uso de la sentencia printf() 1. */ #include <stdio.h> main() /* Saca por pantalla una suma */ { int a=20,b=10; printf("El valor de a es %dn",a); printf("El valor de b es %dn",b); printf("Por tanto %d+%d=%d",a,b,a+b); } Los modificadores más utilizados son: %c %d %u %o %x %e %f %s %p Un único carácter Un entero con signo, en base decimal Un entero sin signo, en base decimal Un entero en base octal Un entero en base hexadecimal Un número real en coma flotante, con exponente Un número real en coma flotante, sin exponente Una cadena de caracteres Un puntero o dirección de memoria Ejemplo: /* Uso de la sentencia printf() 2. */ #include <stdio.h> main() /* Modificadores 1 */ { char cad[]="El valor de"; int a=-15; unsigned int b=3; 12
  17. 17. float c=932.5; printf("%s a es %dn",cad,a); printf("%s b es %un",cad,b); printf("%s c es %e o %f",cad,c,c); } El formato completo de los modificadores es el siguiente: % [signo] [longitud] [.precisión] [l/L] conversión Signo: indicamos si el valor se ajustará a la izquierda, en cuyo caso utilizaremos el signo menos, o a la derecha. Longitud: especifica la longitud máxima del valor que aparece por pantalla. Si la longitud es menor que el número de dígitos del valor, éste aparecerá ajustado a la izquierda. Precisión: indicamos el número máximo de decimales que tendrá el valor. l/L: utilizamos l cuando se trata de una variable de tipo long y L cuando es de tipo double. Ejemplo: /* Uso de la sentencia printf() 3. */ #include <stdio.h> main() /* Modificadores 2 */ { char cad[ ]="El valor de"; int a=25986; long int b=1976524; float c=9.57645; printf("%s a es %9dn",cad,a); printf("%s b es %ldn",cad,b); printf("%s c es %.3f",cad,c); }  Sentencia scanf( ) La rutina scanf permite entrar datos en la memoria del ordenador a través del teclado. 13
  18. 18. El prototipo de la sentencia scanf es el siguiente: scanf(control,arg1,arg2...); En la cadena de control indicaremos, por regla general, los modificadores que harán referencia al tipo de dato de los argumentos. Al igual que en la sentencia printf los modificadores estarán formados por el carácter % seguido de un carácter de conversión. Los argumentos indicados serán, nuevamente, las variables. La principal característica de la sentencia scanf es que necesita saber la posición de la memoria del ordenador en que se encuentra la variable para poder almacenar la información obtenida. Para indicarle esta posición utilizaremos el símbolo ampersand &, que colocaremos delante del nombre de cada variable. Esto no será necesario en los arrays. Ejemplo: /* Uso de la sentencia scanf(). */ #include <stdio.h> main() /* Solicita dos datos */ { char nombre[10]; int edad; printf("Introduce tu nombre: "); scanf("%s",nombre); printf("Introduce tu edad: "); scanf("%d",&edad); } SENTENCIAS CONDICIONALES Este tipo de sentencias permiten variar el flujo del programa en base a unas determinadas condiciones. Existen varias estructuras diferentes:  Estructura IF...ELSE Sintaxis: if (condición) sentencia; La sentencia solo se ejecuta si se cumple la condición. En caso contrario el programa sigue su curso sin ejecutar la sentencia. 14
  19. 19. Otro formato: if (condición) sentencia1; else sentencia2; Si se cumple la condición ejecutará la sentencia1, sinó ejecutará la sentencia2. En cualquier caso, el programa continuará a partir de la sentencia2. Ejemplo: /* Uso de la sentencia condicional IF. */ #include <stdio.h> main() /* Simula una clave de acceso */ { int usuario,clave=18276; printf("Introduce tu clave: "); scanf("%d",&usuario); if(usuario==clave) printf("Acceso permitido"); else printf("Acceso denegado"); }  Estructura SWITCH Esta estructura se suele utilizar en los menús, de manera que según la opción seleccionada se ejecuten una serie de sentencias. Su sintaxis es: switch (variable){ case contenido_variable1: sentencias; break; case contenido_variable2: sentencias; break; default: sentencias; } 15
  20. 20. Cada case puede incluir una o más sentencias sin necesidad de ir entre llaves, ya que se ejecutan todas hasta que se encuentra la sentencia BREAK. La variable evaluada sólo puede ser de tipo entero o caracter. default ejecutará las sentencias que incluya, en caso de que la opción escogida no exista. Ejemplo: /* Uso de la sentencia condicional SWITCH. */ #include <stdio.h> main() /* Escribe el día de la semana */ { int dia; printf("Introduce el día: "); scanf("%d",&dia); switch(dia){ case 1: printf("Lunes"); break; case 2: printf("Martes"); break; case 3: printf("Miércoles"); break; case 4: printf("Jueves"); break; case 5: printf("Viernes"); break; case 6: printf("Sábado"); break; case 7: printf("Domingo"); break; } } BUCLES Los bucles son estructuras que permiten ejecutar partes del código de forma repetida mientras se cumpla una condición. Esta condición puede ser simple o compuesta de otras condiciones unidas por operadores lógicos.  Sentencia WHILE Su sintaxis es: while (condición) sentencia; 16
  21. 21. Con esta sentencia se controla la condición antes de entrar en el bucle. Si ésta no se cumple, el programa no entrará en el bucle. Naturalmente, si en el interior del bucle hay más de una sentencia, éstas deberán ir entre llaves para que se ejecuten como un bloque. Ejemplo: /* Uso de la sentencia WHILE. */ #include <stdio.h> main() /* Escribe los números del 1 al 10 */ { int numero=1; while(numero<=10) { printf("%dn",numero); numero++; } } Sentencia DO...WHILE Su sintaxis es: do{ sentencia1; sentencia2; }while (condición); Con esta sentencia se controla la condición al final del bucle. Si ésta se cumple, el programa vuelve a ejecutar las sentencias del bucle. La única diferencia entre las sentencias while y do-while es que con la segunda el cuerpo del bucle se ejecutará por lo menos una vez. Ejemplo: /* Uso de la sentencia DO...WHILE. */ #include <stdio.h>¡ main() /* Muestra un menú si no se pulsa 4 */ { char seleccion; 17
  22. 22. do{ printf("1.- Comenzarn"); printf("2.- Abrirn"); printf("3.- Grabarn"); printf("4.- Salirn"); printf("Escoge una opción: "); seleccion=getchar(); switch(seleccion){ case '1':printf("Opción 1"); break; case '2':printf("Opción 2"); break; case '3':printf("Opción 3"); } }while(seleccion!='4'); } Sentencia FOR Su sintaxis es: for (inicialización;condición;incremento){ sentencia1; sentencia2; } La inicialización indica una variable de control que condiciona la repetición del bucle. Si hay más, van separadas por comas: for (a=1,b=100;a!=b;a++,b- -){ El flujo del bucle FOR transcurre de la siguiente forma: Ejemplo: /* Uso de la sentencia FOR. */ #include <stdio.h> main() /* Escribe la tabla de multiplicar */ { 18
  23. 23. int num,x,result; printf("Introduce un número: "); scanf("%d",&num); for (x=0;x<=10;x++){ result=num*x; printf("n%d por %d = %dn",num,x,result); } } Sentencia BREAK Esta sentencia se utiliza para terminar la ejecución de un bucle o salir de una sentencia SWITCH. Sentencia CONTINUE Se utiliza dentro de un bucle. Cuando el programa llega a una sentencia CONTINUE no ejecuta las líneas de código que hay a continuación y salta a la siguiente iteración del bucle. Y aquí termina el capítulo dedicado a los bucles. Existe otra sentencia, GOTO, que permite al programa saltar hacia un punto identificado con una etiqueta, pero el buen programador debe prescindir de su utilización. Es una sentencia muy mal vista en la programación en 'C'. Ejemplo: /* Uso de la sentencia CONTINUE. */ #include <stdio.h> main() /* Escribe del 1 al 100 menos el 25 */ { int numero=1; while(numero<=100) { if (numero==25) { numero++; 19
  24. 24. continue; } printf("%dn",numero); numero++; } } FUNCIONES  Tiempo de vida de los datos Según el lugar donde son declaradas puede haber dos tipos de variables. Globales: las variables permanecen activas durante todo el programa. Se crean al iniciarse éste y se destruyen de la memoria al finalizar. Pueden ser utilizadas en cualquier función. Locales: las variables son creadas cuando el programa llega a la función en la que están definidas. Al finalizar la función desaparecen de la memoria. Si dos variables, una global y una local, tienen el mismo nombre, la local prevalecerá sobre la global dentro de la función en que ha sido declarada. Dos variables locales pueden tener el mismo nombre siempre que estén declaradas en funciones diferentes. Ejemplo: /* Variables globales y locales. */ #include <stdio.h> int num1=1; main() /* Escribe dos cifras */ { int num2=10; printf("%dn",num1); printf("%dn",num2); } 20
  25. 25.  Funciones Las funciones son bloques de código utilizados para dividir un programa en partes más pequeñas, cada una de las cuáles tendrá una tarea determinada. Su sintaxis es: tipo_función nombre_función (tipo y nombre de argumentos) { bloque de sentencias } Tipo función: puede ser de cualquier tipo de los que conocemos. El valor devuelto por la función será de este tipo. Por defecto, es decir, si no indicamos el tipo, la función devolverá un valor de tipo entero ( int ). Si no queremos que retorne ningún valor deberemos indicar el tipo vacío ( void ). Nombre función: es el nombre que le daremos a la función. Tipo y nombre de argumentos: son los parámetros que recibe la función. Los argumentos de una función no son más que variables locales que reciben un valor. Este valor se lo enviamos al hacer la llamada a la función. Pueden existir funciones que no reciban argumentos. Bloque de sentencias: es el conjunto de sentencias que serán ejecutadas cuando se realice la llamada a la función. Las funciones pueden ser llamadas desde la función main o desde otras funciones. Nunca se debe llamar a la función main desde otro lugar del programa. Por último recalcar que los argumentos de la función y sus variables locales se destruirán al finalizar la ejecución de la misma.  Declaración de las funciones Al igual que las variables, las funciones también han de ser declaradas. Esto es lo que se conoce como prototipo de una función. Para que un programa en C sea compatible entre distintos compiladores es imprescindible escribir los prototipos de las funciones. Los prototipos de las funciones pueden escribirse antes de la función main o bien en otro fichero. En este último caso se lo indicaremos al compilador mediante la directiva #include. En el ejemplo adjunto podremos ver la declaración de una función, prototipo. Al no recibir ni retornar ningún valor, está declarada como void en ambos lados. También vemos que existe una variable global llamada num. Esta variable es reconocible en todas las funciones del programa. Ya en la función main 21
  26. 26. encontramos una variable local llamada num. Al ser una variable local, ésta tendrá preferencia sobre la global. Por tanto la función escribirá los números 10 y 5. Ejemplo: /* Declaración de funciones. */ #include <stdio.h> void funcion(void); /* prototipo */ int num=5; /* variable global */ main() /* Escribe dos números */ { int num=10; /* variable local */ printf("%dn",num); funcion(); /* llamada */ } void funcion(void) { printf("%dn",num); }  Paso de parámetros a una función Las funciones pueden retornar un valor. Esto se hace mediante la instrucción return, que finaliza la ejecución de la función, devolviendo o no un valor. En una misma función podemos tener más de una instrucción return. La forma de retornar un valor es la siguiente: return ( valor o expresión ); El valor devuelto por la función debe asignarse a una variable. De lo contrario, el valor se perderá. En el ejemplo puedes ver lo que ocurre si no guardamos el valor en una variable. Fíjate que a la hora de mostrar el resultado de la suma, en el printf, también podemos llamar a la función. Ejemplo: /* Paso de parámetros. */ #include <stdio.h> int suma(int,int); /* prototipo */ 22
  27. 27. main() /* Realiza una suma */ { int a=10,b=25,t; t=suma(a,b); /* guardamos el valor */ printf("%d=%d",suma(a,b),t); suma(a,b); /* el valor se pierde */ } int suma(int a,int b) { return (a+b); } Paso de parámetros Existen dos formas de enviar parámetros a una función: Por valor: cualquier cambio que se realice dentro de la función en el argumento enviado, NO afectará al valor original de las variables utilizadas en la llamada. Es como si trabajáramos con una copia, no con el original. No es posible enviar por valor arrays, deberemos hacerlo por referencia. Por referencia: lo que hacemos es enviar a la función la dirección de memoria donde se encuentra la variable o dato. Cualquier modificación SI afectará a las variables utilizadas en la llamada. Trabajamos directamente con el original. Ejemplo: /* Paso por valor. */ #include <stdio.h> void intercambio(int,int); main() /* Intercambio de valores */ { int a=1,b=2; printf("a=%d y b=%d",a,b); intercambio(a,b); /* llamada */ printf("a=%d y b=%d",a,b); } void intercambio (int x,int y) { int aux; aux=x; x=y; 23
  28. 28. y=aux; printf("a=%d y b=%d",x,y); } Para enviar un valor por referencia se utiliza el símbolo &, ampersand, delante de la variable enviada. Esto le indica al compilador que la función que se ejecutará tendrá que obtener la dirección de memoria en que se encuentra la variable. Vamos a fijarnos en los ejemplos. En el ejemplo anterior podrás comprobar que antes y después de la llamada, las variables mantienen su valor. Solamente se modifica en la función intercambio-paso por valor. En el siguiente ejemplo las variables intercambian su valor tras la llamada de la función-paso por referencia. Las variables con un * son conocidas como punteros, el único dato en 'C' que puede almacenar una dirección de memoria. Ejemplo: /* Paso por referencia. */ #include <stdio.h> void intercambio(int *,int *); main() /* Intercambio de valores */ { int a=1,b=2; printf("a=%d y b=%d",a,b); intercambio(&a,&b); /* llamada */ printf("a=%d y b=%d",a,b); } void intercambio (int *x,int *y) { int aux; aux=*x; *x=*y; *y=aux; printf("a=%d y b=%d",*x,*y); } 24
  29. 29. Los argumentos de la función main: La función main no podía ser menos y también puede recibir argumentos, en este caso desde el exterior. Los argumentos que puede recibir son: argc: es un contador. Su valor es igual al número de argumentos escritos en la línea de comandos, contando el nombre del programa que es el primer argumento. argv: es un puntero a un array de cadenas de caracteres que contiene los argumentos, uno por cadena. En este ejemplo vamos a ver un pequeño programa que escribirá un saludo por pantalla. El programa FUNCION6.EXE. Ejemplo: /* Argumentos de la main. */ #include <stdio.h> main(int argc,char *argv[]) /* argumentos */ { printf("nCurso de Programación en C - Copyright (c) 1997-2001, Sergio Pachon"); printf("Programa de ejemplo.nn"); if (argc<2) { printf("Teclee: funcion6 su_nombre"); exit(1); /* fin */ } printf("Hola %s",argv[1]); } VECTORES Un vector es un array unidimensional, es decir, sólo utiliza un índice para referenciar a cada uno de los elementos. Un array es un identificador que referencia un conjunto de datos del mismo tipo. Imagina un tipo de dato int; podremos crear un conjunto de datos de ese tipo y utilizar uno u otro con sólo cambiar el índice que lo referencia. El índice será un valor entero y positivo. En C los arrays comienzan por la posición 0. 25
  30. 30. Su declaración será: tipo nombre [tamaño]; El tipo puede ser cualquiera de los ya conocidos y el tamaño indica el número de elementos del vector, se debe indicar entre corchetes [ ]. En el ejemplo puedes observar que la variable i es utilizada como índice, el primer for sirve para rellenar el vector y el segundo para visualizarlo. Como ves, las posiciones van de 0 a 9, total 10 elementos. Ejemplo: /* Declaración de un array. */ #include <stdio.h> main() /* Rellenamos del 0 - 9 */ { int vector[10],i; for (i=0;i<10;i++) vector[i]=i; for (i=0;i<10;i++) printf(" %d",vector[i]); } Podemos inicializar, asignarle valores un vector en el momento de declararlo. Si lo hacemos así no es necesario indicar el tamaño. Su sintaxis es: tipo nombre []={ valor 1, valor 2...} Ejemplos: int vector[ ]={1,2,3,4,5,6,7,8}; char vector[ ]="programador"; char vector[ ]={'p','r','o','g','r','a','m','a','d','o','r'}; Una particularidad con los vectores de tipo char, cadena de caracteres, es que deberemos indicar en que elemento se encuentra el fin de la cadena mediante el carácter nulo (0). Esto no lo controla el compilador, y tendremos que ser nosotros los que insertemos este carácter al final de la cadena. Por tanto, en un vector de 10 elementos de tipo char podremos rellenar un máximo de 9, es decir, hasta vector[8]. Si sólo rellenamos los 5 primeros, hasta vector[4], debemos asignar el carácter nulo a vector[5]. Es muy sencillo: vector[5]='0'; . 26
  31. 31. Ejemplo de cómo se rellena un vector de tipo char. /* Vector de tipo char. */ #include <stdio.h> main() /* Rellenamos un vector char */ { char cadena[20]; int i; for (i=0;i<19 && cadena[i-1]!=13;i++) cadena[i]=getche( ); if (i==19) cadena[i]='0'; else cadena[i-1]='0'; printf("n%s",cadena); } Podemos ver que en el for se encuentran dos condiciones: 1.- Que no se hayan rellenado todos los elementos (i<19). 2.- Que el usuario no haya pulsado la tecla ENTER, cuyo código ASCII es 13. (cadena[x-i]!=13). También podemos observar una nueva función llamada getche( ), que se encuentra en conio.h. Esta función permite la entrada de un carácter por teclado. Después se encuentra un if, que comprueba si se ha rellenado todo el vector. Si es cierto, coloca el carácter nulo en el elemento nº20 (cadena[19]). En caso contrario tenemos el else, que asigna el carácter nulo al elemento que almacenó el carácter ENTER. En resumen: al declarar una cadena deberemos reservar una posición más que la longitud que queremos que tenga dicha cadena. Llamadas a funciones con arrays Como ya se comentó en el tema anterior, los arrays únicamente pueden ser enviados a una función por referencia. Para ello deberemos enviar la dirección de memoria del primer elemento del array. Por tanto, el argumento de la función deberá ser un puntero. Ejemplo: /* Envío de un array a una función. */ #include <stdio.h> void visualizar(int []); /* prototipo */ main() /* rellenamos y visualizamos */ { int array[25],i; 27
  32. 32. for (i=0;i<25;i++) { printf("Elemento nº %d",i+1); scanf("%d",&array[i]); } visualizar(&array[0]); } void visualizar(int array[]) /* desarrollo */ { int i; for (i=0;i<25;i++) printf("%d",array[i]); } En el ejemplo se puede apreciar la forma de enviar un array por referencia. La función se podía haber declarado de otra manera, aunque funciona exactamente igual: declaración o prototipo void visualizar(int *); desarrollo de la función void visualizar(int *array) MATRICES Una matriz es un array multidimensional. Se definen igual que los vectores excepto que se requiere un índice por cada dimensión. Su sintaxis es la siguiente: tipo nombre [tamaño 1][tamaño 2]...; Una matriz bidimensional se podría representar gráficamente como una tabla con filas y columnas. La matriz tridimensional se utiliza, por ejemplo, para trabajos gráficos con objetos 3D. En el ejemplo puedes ver como se rellena y visualiza una matriz bidimensional. Se necesitan dos bucles para cada una de las operaciones. Un bucle controla las filas y otro las columnas. 28
  33. 33. Ejemplo: /* Matriz bidimensional. */ #include <stdio.h> main() /* Rellenamos una matriz */ { int x,i,numeros[3][4]; /* rellenamos la matriz */ for (x=0;x<3;x++) for (i=0;i<4;i++) scanf("%d",&numeros[x][i]); /* visualizamos la matriz */ for (x=0;x<3;x++) for (i=0;i<4;i++) printf("%d",numeros[x][i]); } Si al declarar una matriz también queremos inicializarla, habrá que tener en cuenta el orden en el que los valores son asignados a los elementos de la matriz. Ejemplos: int numeros[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; quedarían asignados de la siguiente manera: numeros[0][0]=1 numeros[0][1]=2 numeros[0][2]=3 numeros[0][3]=4 numeros[1][0]=5 numeros[1][1]=6 numeros[1][2]=7 numeros[1][3]=8 numeros[2][0]=9 numeros[2][1]=10 numeros[2][2]=11 numeros[2][3]=12 También se pueden inicializar cadenas de texto: char dias[7][10]={"lunes","martes","miércoles","jueves","viernes","sábado","domingo" }; 29
  34. 34. Para referirnos a cada palabra bastaría con el primer índice: printf("%s",dias[i]);  PUNTEROS Un puntero es una variable que contiene la dirección de memoria de otra variable. Se utilizan para pasar información entre una función y sus puntos de llamada. Declaración Su sintaxis es la siguiente: tipo *nombre; Donde nombre es, naturalmente, el nombre de la variable, y tipo es el tipo del elemento cuya dirección almacena el puntero. Operadores Existen dos operadores especiales para trabajar con punteros: & y *. El primero devuelve la dirección de memoria de su operando. Por ejemplo, si queremos guardar en el puntero x la dirección de memoria de la variable num, deberemos hacer lo siguiente: x=# El segundo devuelve el valor de la variable cuya dirección es contenida por el puntero. Este ejemplo sitúa el contenido de la variable apuntada por x, es decir num, en la variable a: a=*x; Asignación Los punteros se asignan igual que el resto de las variables. El programa ejemplo mostrará las direcciones contenidas en p1 y p2, que será la misma en ambos punteros. Ejemplo: /* Asignaciones de punteros. */ #include <stdio.h> main() /* Asignamos direcciones */ { int a; int *p1,*p2; 30
  35. 35. p1=&a; p2=p1; printf("%p %p",p1,p2); } Aritmética de direcciones Es posible desplazar un puntero recorriendo posiciones de memoria. Para ello podemos usar los operadores de suma, resta, incremento y decremento (+, -, ++, - -). Si tenemos un puntero ( p1 ) de tipo int ( 2 bytes ), apuntando a la posición 30000 y hacemos: p1=p1+5; el puntero almacenará la posición 30010, porque apunta 5 enteros por encima ( 10 bytes más ). Concepto de estructura Una estructura es un conjunto de una o más variables, de distinto tipo, agrupadas bajo un mismo nombre para que su manejo sea más sencillo. Su utilización más habitual es para la programación de bases de datos, ya que están especialmente indicadas para el trabajo con registros o fichas. La sintaxis de su declaración es la siguiente: { tipo_variable nombre_variable1; tipo_variable nombre_variable2; tipo_variable nombre_variable3; }; Donde tipo-estructura es el nombre del nuevo tipo de dato que hemos creado. Por último, tipo-variable y nombre-variable son las variables que forman parte de la estructura. Para definir variables del tipo que acabamos de crear lo podemos hacer de varias maneras, aunque las dos más utilizadas son éstas: Una forma de definir la estructura: struct trabajador { char nombre[20]; char apellidos[40]; int edad; 31
  36. 36. char puesto[10]; }; struct trabajador fijo, temporal; Otra forma: struct trabajador { char nombre[20]; char apellidos[40]; int edad; char puesto[10]; }fijo, temporal; En el primer caso declaramos la estructura, y en el momento en que necesitamos las variables, las declaramos. En el segundo las declaramos al mismo tiempo que la estructura. El problema del segundo método es que no podremos declarar más variables de este tipo a lo largo del programa. Para poder declarar una variable de tipo estructura, la estructura tiene que estar declarada previamente. Se debe declarar antes de la función main. El manejo de las estructuras es muy sencillo, así como el acceso a los campos o variables de estas estructuras. La forma de acceder a estos campos es la siguiente: variable.campo; Donde variable es el nombre de la variable de tipo estructura que hemos creado, y campo es el nombre de la variable que forma parte de la estructura. Lo veremos mejor con un ejemplo basado en la estructura definida anteriormente: temporal.edad=25; Almacena el valor 25 en el campo edad de la variable temporal de tipo trabajador. Otra característica interesante de las estructuras es que permiten pasar el contenido de una estructura a otra, siempre que sean del mismo tipo naturalmente: fijo=temporal; Al igual que con los otros tipos de datos, también es posible inicializar variables de tipo estructura en el momento de su declaración: 32
  37. 37. struct trabajador fijo={"Pedro","Hernández Suárez", 32, "gerente"}; Si uno de los campos de la estructura es un array de números, los valores de la inicialización deberán ir entre llaves: struct notas { char nombre[30]; int notas[5]; }; struct notas alumno={"Carlos Pérez",{8,7,9,6,10}}; LIBRERÍAS Librería stdio.h printf Función: Escribe en la salida estándar con formato. Sintaxis: printf(formato , arg1 , ...); scanf Función: Lee de la salida estándar con formato. Sintaxis: scanf(formato , arg1 , ...); puts Función: Escribe una cadena y salto de linea. Sintaxis: puts(cadena); gets Función: Lee y guarda una cadena introducida por teclado. Sintaxis: gets(cadena); fopen Función: Abre un fichero en el modo indicado. Sintaxis: pf=fopen(fichero , modo); fclose Función: Cierra un fichero cuyo puntero le indicamos. Sintaxis: fclose(pf); fprintf Función: Escribe con formato en un fichero. Sintaxis: fprintf(pf , formato , arg1 , ...); fgets 33
  38. 38. Función: Lee una cadena de un fichero. Sintaxis: fgets(cadena , longitud , pf); Librería stdlib.h atof Función: Convierte una cadena de texto en un valor de tipo float. Sintaxis: numflo=atof(cadena); atoi Función: Convierte una cadena de texto en un valor de tipo entero. Sintaxis: nument=atoi(cadena); itoa Función: Convierte un valor numérico entero en una cadena de texto. La base generalmente será 10, aunque se puede indicar otra distinta. Sintaxis: itoa(número , cadena , base); exit Función: Termina la ejecución y abandona el programa. Sintaxis: exit(estado); /* Normalmente el estado será 0 */ Librería conio.h clrscr Función: Borra la pantalla. Sintaxis: clrscr( ); clreol Función: Borra desde la posición del cursor hasta el final de la linea. Sintaxis: clreol( ) gotoxy Función: Cambia la posición del cursor a las coordenadas indicadas. Sintaxis: gotoxy(columna , fila); textcolor Función: Selecciona el color de texto (0 - 15). Sintaxis: textcolor(color); textbackground Función: Selecciona el color de fondo (0 - 7). Sintaxis: textbackground(color); wherex Función: Retorna la columna en la que se encuentra el cursor. 34
  39. 39. Sintaxis: col=wherex( ); wherey Función: Retorna la fila en la que se encuentra el cursor. Sintaxis: fila=wherey( ); getch Función: Lee y retorna un único caracter introducido mediante el teclado por el usuario. No muestra el caracter por la pantalla. Sintaxis: letra=getch( ); Librería string.h strlen Función: Calcula la longitud de una cadena. Sintaxis: longitud=strlen(cadena); strcpy Función: Copia el contenido de una cadena sobre otra. Sintaxis: strcpy(copia , original); strcat Función: Concatena dos cadenas. Sintaxis: strcat(cadena1 , cadena2); strcmp Función: Compara el contenido de dos cadenas. Si cadena1 < cadena2 retorna un número negativo. Si cadena1 > cadena2, un número positivo, y si cadena1 es igual que cadena2 retorna 0 ( o NULL ). Sintaxis: valor=strcmp(cadena1 , cadena2); 35
  40. 40. FUNDAMENTOS DE PROGRAMACIÓN Programa.- Conjunto de sentencias ordenadas secuencialmente para generar procesos automáticos. Datos de entrada ELEMENTOS DE UN PROGRAMA Resultados o Datos de salida Procesos Lenguaje de Programación.- Sintaxis que permite generar instrucciones para desarrollar aplicaciones. Librerías Palabras reservadas Identificadores ELEMENTOS DE UN LENGUAJE DE PROGRAMACIÓN 36
  41. 41. PARTES DE UN PROGRAMA  Librerías.- Es una colección de clases y funciones, escritas en el núcleo del lenguaje. #include<conio.h> #include<stdio.h> #include<stdlib.h> #include<math.h>  Variables.- son un tipo de dato, referenciado mediante un identificador llamado de la variable. Su contenido podrá ser modificado a lo largo del programa. int op, j, a, b, c, d, v; float c, v, vt, s, su ,total; char p[15];  Función main.- Indica el comienzo del programa y requiere los paréntesis ( ) a continuación de main( ) o void main (). main () { viod main () {  Función clrscr.- Limpia la pantalla. clrscr();  Impresión de dados. gotoxy(15,2);printf("SUMA DE DOS NUMEROS"); gotoxy(15,14);printf("Eltotal de la suma es = %d ",c);  Lectura de variables.- Lee cualquier carácter, numero o símbolo incrasado desde teclado. gotoxy(6,6);printf("Ingrese un número: ");scanf("%d",&a); gotoxy(6,8);printf("Ingrese otro número: ");scanf("%d",&b);  Funciones.- Las funciones son bloques de código utilizados para dividir un programa en partes más pequeñas, cada una de las cuáles tendrá una tarea determinada. 37
  42. 42. void nun ( ) { if(a>b && a>c) { gotoxy(16,14);printf("%d",a); } else { if(b<a && b>c) { gotoxy(16,15);printf("%d",b); } else { gotoxy(16,16);printf("%d",c); } } } nun ();  Estructura SWITCH.- Esta estructura se suele utilizar en los menús, de manera que según la opción seleccionada se ejecuten una serie de sentencias. switch(op) { case 1: break; case 2: break; case 5: exit; break; }  Procesos.- Suma, resta, multiplicación, división, potencia, radicación. p=r*t; total=r/2.3  Sentencia do while.- Proceso de repetición. do { }while (op==1) 38
  43. 43.  Sentencias “for” para realizar el borde. for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } }  getch.- Esperar a que el usuario presione una tecla para saltar a la siguiente instruccion o finalizar el programa si es que ya no quedan sentencias. getche();  Sentencia IF...ELSE.- solo se ejecuta si se cumple la condición. En caso contrario el programa sigue su curso sin ejecutar la sentencia. if(d>=7) { gotoxy(6,15);printf("Aprobado"); } else { gotoxy(6,15);printf("Suspenso"); }  return.- es una sentencia la cual tiene como finalidad indicarle al compilador que tiene que regresar el valor de retorno que tú le indiques. return(0); 39
  44. 44. Programa Nº1  Diseñe un programa que me permita ingresar un número entero desde teclado de 1 a 7, y q me visualice el nombre del día de la semana que me corresponda. Análisis.- Utilizamos una variable de tipo entera para ingresar por teclado, la sentencia do-while para regresar si el número un no está entre 1-7, un swich para las opciones de los siete días e imprimimos por pantalla el día correspondiente según el número ingresado. DOCUMENTACION #include<stdio.h> #include<conio.h> int a; main () { clrscr(); gotoxy(25,3);printf("DIAS DE LA SEMANA"); do { gotoxy(29,5);printf(" "); gotoxy(10,5);printf("Ingrese un número: ");scanf("%d",&a); }while(a<1 || a>7); switch(a) { case 1: gotoxy(10,7);printf("Lunes"); break; case 2: gotoxy(10,7);printf("Martes"); break; case 3: gotoxy(10,7);printf("Miercoles"); break; case 4: gotoxy(10,7);printf("Jueves"); break; case 5: gotoxy(10,7);printf("Viernes"); break; case 6: gotoxy(10,7);printf("Sábado"); break; case 7: gotoxy(10,7);printf("Domingo"); break; } 40 LIBRERIAS VARIABLES INICIO LECTURA DE VARIABLES SENTENCIA SWICH
  45. 45. FIN getch(); } CORRIDO DEL PROGRAMA 41
  46. 46. Programa Nº2  Diseñe un programa que me permita ingresar 2 números por teclado y realizar la suma de los mismos Análisis.- Utilizamos tres variables de tipo entero, las dos para ingresar por teclado y la otra para realizar la suma, e imprimimos el resultado por pantalla. DOCUMENTACIÓN #include<stdio.h> #include<conio.h> int a,b,c; main () { clrscr(); gotoxy(15,2);printf("SUMA DE DOS NUMEROS"); gotoxy(6,6);printf("Ingrese un número: ");scanf("%d",&a); gotoxy(6,8);printf("Ingrese otro número: ");scanf("%d",&b); c=a+b; gotoxy(15,14);printf("Eltotal de la suma es = %d ",c); getche(); return(0); } 42 LIBRERIAS VARIABLES INICIO LECTURA DE VARIABLES FIN
  47. 47. CORRIDO DEL PROGRAMA Programa Nº3  Diseñe un programa que me permita ingresar 3 números enteros desde teclado que corresponden a 3 notas las mismas que deben estar entre 1 y 10, obtenga el promedio correspondiente y determine su equivalencia.  Si el promedio es mayor o igual a 7, está aprobado.  Si el promedio es mayor o igual a 5 y  Menor que 7 esta suspenso  Si el promedio es menor que 5 esta reprobado Análisis.- Utilizamos cuatro variables de tipo enteras, un do-wille para que las notas solo sean de 1-10, realizamos los procesos e imprimimos el resultado. DOCUMENTACIÓN #include<stdio.h> #include<conio.h> int a,b,c,d; main () { clrscr(); gotoxy(15,2);printf("PROMEDIO"); do { gotoxy(30,6);printf(" "); gotoxy(6,6);printf("Ingrese la primera nota: ");scanf("%d",&a); }while(a<0 || a>10); do { gotoxy(30,8);printf(" "); gotoxy(6,8);printf("Ingrese la segunda nota: ");scanf("%d",&b); 43 LIBRERIAS VARIABLES INICIO LECTURA DE VARIABLES
  48. 48. }while(b<0 || b>10); do { gotoxy(30,10);printf(" "); gotoxy(6,10);printf("Ingrese la tercera nota: ");scanf("%d",&c); }while (c<0 || c>10); d=(a+b+c)/3; gotoxy(6,14);printf("Promedio %d",d); if(d>=7) { gotoxy(6,15);printf("Aprobado"); } else { if(d>=5&&d<7) { gotoxy(6,15);printf("Suspenso"); } else { if(c<5) { gotoxy(6,15);printf("Reprobado"); }} } getche(); return(0); } CORRIDO DEL PROGRAMA 44 LECTURA DE VARIABLES CONDICIONAL “IF” FIN
  49. 49. 45
  50. 50. Programa Nº4  Diseñe un programa que realice la suma de dos números, siempre que el primer valor este entre 3 y 23 y el segundo valor este entre 5 y 17. Análisis.- Utilizamos tres variables de tipo enteras, dos do-while para que cumpla la condición requerida, realizamos el proceso y presentamos resultados DOCUMENTACIÓN #include<stdio.h> #include<conio.h> int a,b,c; main () { clrscr(); gotoxy(15,2);printf("SUMA DE DOS NUMEROS"); do { gotoxy(23,6);printf(" "); gotoxy(6,6);printf("Ingrese un n£mero: ");scanf("%d",&a); }while (a<3 || a>23); do { gotoxy(23,8);printf(" "); gotoxy(6,8);printf("Ingrese otro n£mero: ");scanf("%d",&b); }while (b<5 || b>17); c=a+b; gotoxy(15,14);printf("Eltotal de la suma es = %d ",c); getche(); return(0); } CORRIDO DEL PROGRAMA 46 LIBRERIAS VARIABLES INICIO LECTURA DE VARIABLES FIN
  51. 51. Programa Nº5  Diseñe un programa que me permita obtener las comisiones de ventas de la empresa XYZ, bajo los siguientes condicionamientos si el valor de la venta es igual a >= 3000 y <=5000 el porcentaje es de 5%, >=5000 y <=8500 el porcentaje es de 7%; >=8500 y <=10000 el porcentaje es de 8% >10000 el porcentaje es de 10%; Visualice el valor total de ventas ingresadas y el total de comisiones entregadas el proceso se repite n veces. DOCUMENTACIÓN #include<stdio.h> #include<conio.h> main () { int a=1,b=0,oper; float c,p,v,s,t,f,g,r,q; do { clrscr(); a=1; b=0; gotoxy(30,2);printf("COMISIONES DE VENTAS"); gotoxy(5,5);printf("Ingresar el valor de la venta:");scanf("%f",&c); if((c>2999)&&(c<5001)) { p=(c*5)/100; v=c+p; gotoxy(8,10);printf("La venta total es=%f",v); gotoxy(8,13);printf("La ganancia es=%f",p); } if((c>5000)&&(c<8499)) 47 LIBRERIAS VARIABLES INICIO LECTURA DE VARIABLES
  52. 52. { s=(c*7)/100; t=s+c; gotoxy(8,10);printf("La venta total es=%f",t); gotoxy(8,13);printf("La ganancia es=%f",s); } if((c>8500)&&(c<10001)) { r=(c*8)/100; q=r+c; gotoxy(8,10);printf("La venta total es=%f",q); gotoxy(8,13);printf("La ganancia es=%f",r); } if(c>10000) { f=(c*10)/100; g=f+c; gotoxy(8,10);printf("La venta total es=%f",g); gotoxy(8,13);printf("La ganancia es=%f",f); } gotoxy(30,20);printf("PRESS 1 para continuar o 0 abandonar"); scanf("%d",&oper); } while(oper==1); getch(); } CORRIDO DEL PROGRAMA 48 SENTECIA “IF” FIN
  53. 53. Programa Nº6  Diseñe un programa que me permita ingresar el nombre de una persona y la edad de la misma que debe estar entre 3 y 85, para obtener las siguientes equivalencias:  Si la edad está entre 3 y 5 debe visualizarse: nombre, “es un bebé”  Si la edad es > 5 y <13 debe visualizarse: nombre, “es un niño”  Si la edad es > 13 y ≤ 21 debe visualizarse: nombre, “es un adolescente”  Si la edad es > 21 y ≤ 60 debe visualizarse: nombre, “es un adulto”  Si la edad es > 60 debe visualizarse: nombre, “es un adulto mayor” El programa se repite tantas veces como el usuario lo desee. Análisis.- Utilizamos tres variables, una de tipo entera y otra de tipo carácter, sentencias if-else para realizar las equivalencias requeridas y un do-while para repetir el proceso. DOCUMENTACIÓN #include<stdio.h> #include<conio.h> #include<string.h> void main() { int ed,op; char nombre[15]; do { clrscr(); gotoxy(31,1);printf("Saber edad y equivalencia"); flushall(); gotoxy(10,3);printf("Ingrese nombre: ");gets(nombre); 49 LIBRERIAS VARIABLES INICIO LECTURA DE VARIABLES
  54. 54. do { gotoxy(27,4);printf(" "); gotoxy(10,4);printf("Ingrese la edad: ");scanf("%d",&ed); }while(ed>85 || ed<3); if(ed>=3 && ed<=5) { gotoxy(10,7);printf("Es un bebe"); } else { if(ed>5 && ed<=13) SENTECIA “IF” { gotoxy(10,7);printf("Ni¤o"); } else { if(ed>15 && ed<=21) { gotoxy(10,7);printf("Adolecente"); } else { if(ed>21 && ed<=61) { gotoxy(10,7);printf("Adulto"); } else { gotoxy(10,7);printf("Adulto Mayor"); } } } } gotoxy(10,6);puts(nombre); gotoxy(10,10);printf("Presione 1 para continuar o 0 para salir: ");scanf("%d",&op); }while(op==1); getch(); FIN } } 50
  55. 55. CORRIDO DEL PROGRAMA 51
  56. 56. Programa Nº7  Diseñe un programa que me permita simular la venta de productos en una factura, de la cual necesitamos ingresar el nombre del producto, la cantidad, precio unitario y calcular el precio total. El programa se repite n veces según los productos que el usuario desee ingresar. Análisis.- Utilizamos 15 variables de tipo enteras, decimales y de caracte, un dowhile para que se repita el proceso, realizamos el proceso y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> VARIABLES main() { INICIO int op,j,a=4,b=4,c=4,d=4,v=0; float cant,vuni,vtotal,iva,s,sub,totalp; char p[15]; clrscr(); gotoxy(23,1); printf("SIMULACION DE FACTURA"); gotoxy(5,4); printf("Producto"); IMPRESION gotoxy(20,4); printf("Cantidad"); gotoxy(34,4); printf("Precio Unitario"); gotoxy(55,4); printf("Valor"); do { flushall(); a=a+1;gotoxy(5,a);gets(p); b=b+1;gotoxy(23,b);scanf("%2f",&cant); OPERASIONES c=c+1;gotoxy(39,c);scanf("%2f",&vuni); vtotal=cant*vuni; d=d+1;gotoxy(55,d);printf("%.2f",vtotal); v=v+vtotal; LECTURA DE gotoxy(2,24);printf("presione 1 para ingresar otro producto o 0 para finalizar la factura: ");scanf("%d",&op); }while(op==1); j=v; sub=j; gotoxy(45,21); printf("subtotal: %.2f",sub); iva=(sub*12)/100; IMPRESION gotoxy(50,22); printf("iva: %.2f",iva); vtotal=sub+iva; gotoxy(40,23); printf("valor a pagar: %.2f",vtotal); getch(); FIN } 52
  57. 57. CORRIDO DEL PROGRAMA 53
  58. 58. Programa Nº8  Diseñe un programa que me permita calcular el promedio general de las notas de distintas materias correspondientes al 2do semestre de docencia en informática, en donde cada uno de las notas ingresadas debe estar entre 1 y 10. Análisis.- Utilizamos 6 variables de tipo enteras y decimales realizamos los procesos e imprimimos por pantalla. DOCUMENTACIÓN #include<stdio.h> #include<conio.h> main() { int c=5,n1,n2,n3,op; float prom; clrscr(); gotoxy(27,2);printf("Facultad de Ciencias Humanas"); gotoxy(30,3);printf("Segundo Informatica"); gotoxy(8,5); printf("Modulos nota 1nota 2 nota 3promedio"); gotoxy(5,6); printf("Programacion 1"); gotoxy(5,7); printf("Fisica 2"); gotoxy(5,8); printf("Matematica Basica"); gotoxy(5,9); printf("M. de la Investigacion"); gotoxy(5,10);printf("Trabajo en Equipo"); gotoxy(5,11);printf("Realidad Nacional"); gotoxy(5,12);printf("Ntics"); do { c=c+1; do { gotoxy(39,c);printf(" "); gotoxy(39,c);scanf("%d",&n1); } while (n1>10); do { gotoxy(49,c);printf(" "); gotoxy(49,c);scanf("%d",&n2); } while (n2>10); do { gotoxy(60,c);printf(" "); gotoxy(60,c);scanf ("%d",&n3); 54 LIBRERIAS VARIABLES INICIO IMPRESION SENTECIA “IF”
  59. 59. } while (n3>10); prom=(n1+n2+n3)/3; gotoxy(70,c);printf("%.2f",prom); gotoxy(5,15);printf("presione 1 para continuar o 0 para salir");scanf("%d",&op); } while (op==1); getch(); FIN } 55
  60. 60. CORRIDO DEL PROGRAMA Programa Nº9  Realice un programa en C++ que me permita obtener el líquido a recibir de un empleado bajo los siguientes parámetros: El empleado percibe un salario mínimo vital el mismo que depende de su categoría, existen 3 posibles alternativas, este dato deberá ser ingresada al inicio del programa conjuntamente con el nombre del empleado:  Categoría 1 180,00  Categoría 2 250,00  Categoría 3 380,00 A este salario mínimo vital se le incluye algunos rubros que son: 1. Horas extras, las mimas que no pueden exceder 8, cada hora extra cuesta Usd. 1,80. 2. Bono familiar la misma que esta condicionada. Si el empleado tiene mas de dos hijos se le paga Usd. 4,50 por cada hijo caso contrario se le reconoce Usd. 6,20 por cada hijo. 3. Obtenga el valor del IESS que es el 11,5 % del nominal 4. Se le descuenta el 2% del nominal como aporte a la asociación 5. Obtenga los valores correspondientes de ingresos, egresos y total a recibir El programa se genera n veces. 56
  61. 61. Análisis.- Utilizamos variables de tipo enteras, decimales y de carácter, dowhile para repetir el proceso, if para que cumpla las condiciones requeridas, realizamos los proceso e imprimimos el resultado por pantalla. DOCUMENTACIÓN #include<stdio.h> LIBRERIAS #include<conio.h> main () VARIABLES { floatx=180,y=250,z=380,s,iess,i=11.5,dcto,a=2,p=1.80,ex,hex,j=4.50,k=6.20, INICIO b,in,eg,t; int c,h,op; char n[50]; do { flushall(); clrscr(); gotoxy(31,3); printf("INGRESO DE DATOS"); gotoxy(2,5); printf("Ingrese su nombre: ");flushall(); gets(n); do { gotoxy(2,8); printf("Escoja su categoria: 1, 2 o 3: "); scanf("%d",&c); } while(c>3 || c<1); gotoxy(2,11); printf("Cantidad de hijos registrados: "); scanf("%d",&h); do { gotoxy(2,14);printf("Horas extras registradas: "); scanf("%f",&hex); } while(hex<1 || hex>8); clrscr(); gotoxy(5,3); printf("********************ROL DE PAGOS********************"); gotoxy(5,5); printf("Empleado: %s",n); gotoxy(5,6); printf("Corresponde: Septiembre 2013"); gotoxy(5,7); printf("Dias laborados: 30 dias"); gotoxy(5,8); printf("**************************"); gotoxy(10,10); printf("Ingresos"); LECTURA DE gotoxy(46,10); printf("Egresos"); gotoxy(5,12); printf("Sueldo nominal "); if(c==1) { s=x; gotoxy(21,12); printf("%.2f",s); } if(c==2) { s=y; gotoxy(21,12); printf("%.2f",s); } 57
  62. 62. if(c==3) { s=z; gotoxy(21,12); printf("%.2f",s); } iess=(s*i)/100; gotoxy(38,12); printf("Seguro: "); gotoxy(52,12); printf("%.2f",iess); dcto=(s*a)/100; gotoxy(38,13); printf("Dcto. Asoc.: "); gotoxy(52,13); printf("%.2f",dcto); ex=(hex*p); gotoxy(5,13); printf("Horas extras: "); gotoxy(21,13);printf("%.2f",ex); gotoxy(5,14); printf("Bono Familiar: "); if (h>2) { b=(h*j); gotoxy(21,14);printf("%.2f",b); } if (h<3) { b=(h*k); gotoxy(21,14);printf("%.2f",b); } in=(s+ex+b); gotoxy(5,18); printf("Total Ingresos: "); gotoxy(21,18);printf("%.2f",in); eg=(iess+dcto); gotoxy(38,18);printf("Total Egresos: "); gotoxy(52,18);printf("%.2f",eg); t=(in-eg); gotoxy(38,24);printf("TOTAL A RECIBIR: "); gotoxy(55,24);printf("%.2f",t); gotoxy(37,23);printf("*************************"); gotoxy(37,25);printf("*************************"); gotoxy(5,23); printf("presione 1 para regresar o "); gotoxy(5,24); printf("presione 0 para salir: "); scanf("%d",&op); } while (op==1); getch(); } 58 IMPRESION IMPRESION FIN
  63. 63. 59
  64. 64. CORRIDO DEL PROGRAMA 60
  65. 65. Programa Nº10  Diseñe un programa que me permita imprimir un borde de pantalla. Análisis.- Utilizamos una variable de tipo entera y un ciclo for para imprimir el borde. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> main() { int i,limite,fila=6,op; fila=6; clrscr(); for (i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for (i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } getch(); } VARIABLES INICIO SENTENCIA “FOR” FIN 61
  66. 66. CORRIDO DEL PROGRAMA Programa Nº11  Diseñe un programa que me permita visualizar la serie de los números pares y los impares que existen hasta el número límite ingresado desde teclado. Análisis.- Utilizamos 4 variables de tipo entera, realizamos el proceso y presentamos resultados DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> main() { int i,limite,fila=6,op; do { fila=6; clrscr(); for (i=1;i<=80;i++) VARIABLES INICIO 62
  67. 67. { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } SENTENCIA “FOR” for (i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } gotoxy(5,2);printf("ingrese el limite: ");scanf("%d",&limite); gotoxy(20,4);printf("Pares:"); for (i=2;i<=limite;i+=2) { gotoxy(23,fila);printf("%d",i); fila=fila+1; } SENTENCIA “FOR” fila=6; gotoxy(42,4);printf("Impares:"); for (i=1;i<=limite;i+=2) { gotoxy(46,fila);printf("%d",i); fila=fila+1; } gotoxy(60,21);printf("presione:"); gotoxy(60,22);printf("1 para continuar"); gotoxy(60,23);printf("0 para salir: "); scanf("%d",&op); } while(op==1); getch(); } FIN 63
  68. 68. CORRIDO DEL PROGRAMA 64
  69. 69. Programa Nº612  Realizar un programa y visualizar los números primos. Análisis.- Activamos la librerías, utilizamos variables de tipo enteras, dowhile para que cumpla la condición requerida, realizamos el proceso y presentamos resultados DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> #include<string.h> main() { int i, j, fla=7, lim, cnt=0, resul, op; do { fla=7; clrscr(); gotoxy(35,3);printf("NUMEROS PRIMOS"); for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } gotoxy(5,8);printf("ingrese limite: ");scanf("%d",&lim); for(i=1;i<=lim;i++) { cnt=0; for(j=1;j<=i;j++) { resul=i%j; if(resul==0) { cnt=cnt+1; } } if(cnt==2) { gotoxy(40,fla);printf("%d",i); fla=fla+1; } } 65 VARIABLES INICIO SENTENCIA “FOR” SENTENCIA “FOR”
  70. 70. CORRIDO DEL PROGRAMA Programa Nº13  Diseñe un programa que me permita visualizar la factorial de un número ingresado desde teclado. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for y realizamos los proceso y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> main() { int i,j,m,l,f=1,op; do { clrscr(); f=1; //borde de pantalla m=10; for (i=1;i<=80;i++) { gotoxy(i,1); printf("*"); gotoxy(i,24);printf("*"); } VARIABLES INICIO SENTENCIA “FOR” 66
  71. 71. for (i=1;i<=24;i++) { gotoxy(1,i); printf("*"); gotoxy(80,i);printf("*"); } gotoxy(31,3);printf("FACTORIALES"); gotoxy(15,7);printf("ingrese el limite: ");scanf("%d",&l); for (j=1;j<=l;j++) { f=f*j; gotoxy(20,m);printf("El factorial de: %d = %d",j,f); m=m+1; } gotoxy(15,22);printf("presione 1 para continuar o 0 para salir: ");scanf("%d",&op); } while (op==1); getch(); } 67 LECTURA DE FIN
  72. 72. CORRIDO DEL PROGRAMA Programa Nº14  Diseñe un programa que me permita ejercer la tabla de multiplicación de cualquier factor imprimido desde teclado y por cualquier limite impreso desde teclado, el programa se genera n veces, diseñe el borde de la pantalla. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> main () { int fac,lim,i,n,m,j,op ; do { clrscr(); //borde de pantalla m=9; for (i=1;i<=80;i++) { gotoxy(i,1); printf("*"); gotoxy(i,24);printf("*"); } for (i=1;i<=24;i++) VARIABLES INICIO SENTENCIA “FOR” 68
  73. 73. { gotoxy(1,i); printf("*"); gotoxy(80,i);printf("*"); } //tabla de multiplicar gotoxy(31,3); printf("TABLAS DE MULTIPLICAR"); gotoxy(10,5); printf("Factor: ");scanf("%d",&fac); gotoxy(10,7); printf("Limite: ");scanf("%d",&lim); for(j=1;j<=lim;j++) { n=fac*j; gotoxy(19,m); printf("%d",fac); gotoxy(21,m); printf("*"); gotoxy(23,m); printf("%d",j); gotoxy(25,m); printf("="); gotoxy(27,m); printf("%d",n); m=m+1; } gotoxy(8,22); printf("presione 1 para regresar o 0 para salir: ");scanf("%d",&op); } while (op==1); getch(); } 69 FIN
  74. 74. CORRIDO DEL PROGRAMA Programa Nº15  Diseñe un programa en c++ que me permita visualizar los números primos con repetición y el borde. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<conio.h> #include<stdio.h> main() { int i=0,j=0,lt,c,res=0,op=1,nc=0; do { clrscr(); for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(79,i);printf("*"); } for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); VARIABLES INICIO SENTENCIA “FOR” 70
  75. 75. } gotoxy(29,2);printf("NUMEROS PRIMOS"); gotoxy(6,4);printf("INGRESE EL LIMITE : ");scanf("%d",&lt); gotoxy(6,6);printf("1"); c=2; for(i=2;i<=lt;i++) { for(j=1;j<=c;j++) { if(i%j==0) { nc=nc+1; } } if(nc==2) { printf("%6d",i); } nc=0; c=c+1; } gotoxy(2,23),printf("REPETIR 1 Y 0 PARA SALIR : ");scanf("%d",&op); } while(op==1); getch(); FIN } 71
  76. 76. CORRIDO DEL PROGRAMA Programa Nº16  Diseñe un programa que me permita generar cualquier seria de números. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los proceso y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<conio.h> #include<stdio.h> void main() { int limite,i,fla,op; do { clrscr(); for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) VARIABLES INICIO SENTENCIA “FOR” 72
  77. 77. { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } flushall(); gotoxy(25,5);printf("Series"); gotoxy(15,6);printf("Ingrese limite: ");scanf("%d",&limite); fla=6; for(i=2;i<=limite;i+=2) { gotoxy(20,fla+1);printf("%d",i); fla=fla+1; } fla=7; for(i=1;i<=limite;i+=2) { gotoxy(40,fla);printf("%d",i); fla=fla+1; } gotoxy(15,20);printf("Desea salir 1/0: ");scanf("%d",&op); }while(op==1); getch(); } 73 SENTENCIA “FOR” FIN
  78. 78. CORRIDO DEL PROGRAMA Programa Nº17  Diseñe un programa que me permita generar una serie de números, en donde el numerados es cualquier factor ingresado desde teclado, y el numerador es la serie de los números impares. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> void main () { int i,l,j,c,d,s,p,op,fa; do { clrscr(); for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) VARIABLES INICIO SENTENCIA “FOR” 74
  79. 79. { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } gotoxy(16,2);printf("SERIE DE NUMEROS NUMERADOR CUALQUIER,DENOMINADOR IMPAR"); gotoxy(10,3);printf("Ingrse el limite: ");scanf("%d",&l); gotoxy(10,4);printf("ingrese el factor:");scanf("%d",&fa); c=0; d=1; for(i=1;i<=l;i++) { c=c+3; gotoxy(5,6+i);printf("%d",c); d=d+2; gotoxy(13,6+i);printf("%d",d); gotoxy(9,6+i);printf("/"); } gotoxy(10,20);printf("Desea continuar 1 caso contario 0: ");scanf("%d",&op); }while(op==1); getch(); } 75 LECTURA DE FIN
  80. 80. CORRIDO DEL PROGRAMA Programa Nº18  Realice un programa que me permita general la siguiente serie de datos: N= 5 Factor impar como numerador Factorial como denominador Análisis.- Utilizamos variables de tipo enteras y decimales, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<conio.h> #include<stdio.h> void main() { int s,f,i,d,j,op; float factorial; do { clrscr(); for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); VARIABLES INICIO SENTENCIA “FOR” 76
  81. 81. } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } gotoxy(15,2);printf("SERIE DE NUMEROS CON NUMERADOR IMPAR E FACTORIAL DENOMINADOR"); gotoxy(10,3);printf("Ingrse el limite: ");scanf("%d",&s); do { gotoxy(32,4);printf(" "); gotoxy(10,4);printf("ingrese el factor:");scanf("%d",&f); } while(f%2==0); factorial=1; for(i=1;i<=s;i++) { factorial=factorial*i; gotoxy(5,6+i);printf("%d",f); f=f+2; gotoxy(13,6+i);printf("%4.0f",factorial); gotoxy(9,6+i);printf("/"); } gotoxy(10,20);printf("Desea continuar 1 caso contario 0: ");scanf("%d",&op); }while(op==1); getch(); } 77 IMPRESION FIN
  82. 82. CORRIDO DEL PROGRAMA Programa Nº19ç  Generar n elementos de la siguiente serie, cualquier factor ingresando desde teclado como numerador, el denominador números pares. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN #include<stdio.h> #include<conio.h> void main () { int i,l,j,c,d,s,p,op,fa; do { clrscr(); for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); LIBRERIAS VARIABLES INICIO SENTENCIA “FOR” 78
  83. 83. } gotoxy(16,2);printf("SERIE DE NUMEROS NUMERADOR CUALQUIER,DENOMINADOR PAR"); gotoxy(10,3);printf("Ingrse el limite: ");scanf("%d",&l); gotoxy(10,4);printf("ingrese el factor:");scanf("%d",&fa); c=0; d=0; for(i=1;i<=l;i++) { c=c+3; gotoxy(5,6+i);printf("%d",c); d=d+2; gotoxy(13,6+i);printf("%d",d); gotoxy(9,6+i);printf("/"); } gotoxy(10,20);printf("Desea continuar 1 caso contario 0: ");scanf("%d",&op); }while(op==1); getch(); } 79 IMPRESION FIN
  84. 84. CORRIDO DEL PROGRAMA Programa Nº20  Genere una serie de datos que lleve por numerador el factorial y por denominador la serie de Fibonacci Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<conio.h> #include<stdio.h> main() { int i, limit, fibon=0, colum=5, b=1, c=0, fac=1, op; do { fibon=0, colum=5, b=1, c=0, fac=1; clrscr(); for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) { 80 VARIABLES INICIO SENTENCIA “FOR”
  85. 85. gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } gotoxy(17,3);printf("SERIE NUMERADOR FACTORIAL Y DENOMINADOR FIBONACCI"); gotoxy(4,5);printf("numero a visualizar: ");scanf("%d",&limit); LECTURA DE for(i=1;i<=limit;i++) { gotoxy(colum,9);printf("%d",fibon); fibon=b+c; b=c; OPERACIONES c=fibon; gotoxy(colum,8);printf("-"); gotoxy(colum,7);printf("%d",fac); fac=fac*i; colum=colum+5; } gotoxy(3,22);printf("PRESIONE 1 PARA REPETIR LA SERIE O 0 PARA LECTURA DE FINALIZAR>> ");scanf("%d",&op); } while(op==1); getch(); } FIN 81
  86. 86. CORRIDO DEL PROGRAMA Programa Nº21  Genere la siguiente serie de datos primos en el numerador e impares en el denominador. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, sentencias if realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> #include<string.h> main() { int i, j, np, cot=0, c=5, resul, op, colum=15, imp=1, aux; do { imp=1; colum=15; c=10; clrscr(); VARIABLES 82 INICIO
  87. 87. gotoxy(16,3);printf("SERIE NUMERADOR PRIMOS DENOMINADOR IMPARES"); for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); SENTENCIA “FOR” gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } gotoxy(3,5);printf("Limite: ");scanf("%d",&np); gotoxy(10,7);printf("1"); gotoxy(8,6);printf("Serie: "); aux=0; for(i=1;i<=(2*np);i++) { if(aux==np) {break; } SENTENCIA “FOR” cot=0; for(j=1;j<=i;j++) { resul=i%j; if(resul==0) { cot=cot+1; } } if(cot==2) { gotoxy(colum,7);printf("%d",i); aux=aux+1; gotoxy(colum,8);printf("-"); IMPRESION colum=colum+5; gotoxy(c,9);printf("%d",imp); imp=imp+2; c=c+5; } } gotoxy(3,23);printf("PRESIONE 1 PARA REPETIR EL PROCESO O 0 PARA FINALIZAR: ");scanf("%d",&op); } while(op==1); getch(); FIN } 83
  88. 88. CORRIDO DEL PROGRAMA 84
  89. 89. Programa Nº22  Realice un menú que me permita realizar las conversiones básicas de metro, kilometro, hectómetro y decímetro. Análisis.- Activamos las librerías, utilizamos variables de tipo enteras, y decimales, do-while para que cumpla la condición requerida, sentencias for, un swich para las opciones, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<conio.h> #include<stdio.h> VARIABLES #include<stdlib.h> INICIO void borde() { int i; clrscr(); for(i=1;i<=80;i++) { gotoxy(i,1);printf("±"); gotoxy(i,24);printf("±"); SENTENCIA “FOR” } for(i=1;i<=24;i++) { gotoxy(1,i);printf("±"); gotoxy(80,i);printf("±"); } } void main() { int op,col=8; float km,nu,dam,hm,m; clrscr(); do { borde(); gotoxy(32,3);printf("CONVERSIONES BASICAS"); gotoxy(32,2);printf("////////////////////"); IMPRESION gotoxy(32,4);printf("////////////////////"); gotoxy(5,6);printf("1.- De Metros a Km - Hm - Dam"); gotoxy(5,8);printf("2.- De Kilometros a M - Hm - Dam"); gotoxy(5,10);printf("3.- De Hectometros a M - Km - Dam"); gotoxy(5,12);printf("4.- De Decametros a M - Km - Hm"); gotoxy(5,14);printf("5.- Salir"); gotoxy(5,22);printf("Que opcion desea realizar: ");scanf("%d",&op); switch(op) { case 1: clrscr(); 85
  90. 90. borde(); gotoxy(33,3);printf("De Metros a Km - Hm - Dam"); gotoxy(5,5);printf("Ingrece la cantidad: ");scanf("%f",&nu); km=nu*0.001; hm=nu*0.01; dam=nu*0.1; gotoxy(col,8);printf("Km = %f",km); gotoxy(col,10);printf("Hm = %f",hm); gotoxy(col,12);printf("Dam = %f",dam); break; case 2: clrscr(); borde(); gotoxy(33,3);printf("De Kilometros a M - Hm - Dam"); gotoxy(5,5);printf("Ingrece la cantidad: ");scanf("%f",&nu); m=nu*1000; hm=nu*100; dam=nu*10; gotoxy(col,8);printf("M = %f",m); gotoxy(col,12);printf("Hm = %f",hm); gotoxy(col,10);printf("Dam = %f",dam); break; case 3: clrscr(); borde(); gotoxy(33,3);printf("De Hectometros a M - Km - Dam"); gotoxy(5,5);printf("Ingrece la cantidad: ");scanf("%f",&nu); km=nu*0.1; m=nu*100; dam=nu*10; gotoxy(col,12);printf("Km = %f",km); gotoxy(col,8);printf("M = %f",m); gotoxy(col,10);printf("Dam = %f",dam); break; case 4: clrscr(); borde(); gotoxy(33,3);printf("De Metros a M - Km - Hm"); gotoxy(5,5);printf("Ingrece la cantidad: ");scanf("%f",&nu); km=nu*0.001; hm=nu*0.01; m=nu*10; gotoxy(col,12);printf("Km = %f",km); gotoxy(col,10);printf("Hm = %f",hm); gotoxy(col,8);printf("M = %f",m); break; case 5: exit(0); break; } 86 IMPRESION IMPRESION IMPRESION FIN
  91. 91. gotoxy(3,23);printf("1 PARA VOLVER AL MENU DE DATOS 0 PARA FINALIZAR: ");scanf("%d",&op); } while(op==1); getch(); } 87 FIN
  92. 92. CORRIDO DEL PROGRAMA Programa Nº23  Diseñe un programa que me permita realizar un borde utilizaciones funciones. Análisis.- Utilizamos una variable de tipo enteras, sentencias for para que cumpla la condición requerida, llamamos a la función borde y presentamos resultados. 88
  93. 93. DOCUMENTACIÓN #include<stdio.h> #include<conio.h> #include<stdlib.h> int i; void borde() { for(i=1;i<=80;i++) { gotoxy(i,24);printf("*"); gotoxy(i,1);printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } } void main () { clrscr(); borde(); getch(); } LIBRERIAS VARIABLES INICIO SENTENCIA “FOR” FIN 89
  94. 94. CORRIDO DEL PROGRAMA Programa Nº24 Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> int numero,i,op; void borde() { for(i=1;i<=80;i++) { gotoxy(i,1);printf("• "); gotoxy(i,24);printf("• "); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("• "); gotoxy(80,i);printf("• "); } } void numeros(int num) { for(i=1;i<=numero;i++) VARIABLES INICIO SENTENCIA “FOR” 90
  95. 95. { gotoxy(15,4+i);printf("%d",i); } } void main() { do { clrscr(); borde(); gotoxy(15,4);printf("Numero: ");scanf("%d",&numero); numeros(numero); gotoxy(15,22);printf("Desea salir 1/0: ");scanf("%d",&op); }while(op==1); getch(); } 91 FIN
  96. 96. CORRIDO DEL PROGRAMA Programa Nº25  Diseñe un programa que me permita ingresar tres valores enteros desde teclado entre 4 y 64 y presentarlos en forma ordenada ascendentemente. Análisis.- Utilizamos variables de tipo enteras, do-while para que cumpla la condición requerida, sentencias for, realizamos los procesos y presentamos resultados. DOCUMENTACIÓN LIBRERIAS #include<stdio.h> #include<conio.h> #include<stdlib.h> int i,a,b,c; void borde () { VARIABLES INICIO 92
  97. 97. for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); SENTENCIA “FOR” gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } } void nun ( ) { if(a>b && a>c) { gotoxy(16,14);printf("%d",a); } else { if(b<a && b>c) { gotoxy(16,15);printf("%d",b); } else FUNSION { gotoxy(16,16);printf("%d",c); } if(c<a && c>b) { gotoxy(16,17);printf("%d",c); } else { gotoxy(16,18);printf("%d",b); } } } void main() { clrscr(); borde (); gotoxy(30,3);printf("ASCENDENTE"); do { gotoxy(37,5);printf(" "); gotoxy(12,5);printf("Ingrese el primer numero:");scanf("%d",&a); }while(a<3||a>65); do { gotoxy(37,7);printf(" "); 93
  98. 98. gotoxy(12,7);printf("Ingrese el segundo numero:");scanf("%d",&b); }while(b<3||b>65); do { gotoxy(37,9);printf(" "); gotoxy(12,9);printf("Ingrese el tercer numero:");scanf("%d",&c); }while(c<3||c>65); nun (); getch(); FIN } 94
  99. 99. CORRIDO DEL PROGRAMA 95
  100. 100. 33.-Diseñe un programa utilizando funciones que me permita ingresar 3 valores enteros desde teclado entre 4 y 64 y presentarlos en forma ordenada ascendentemente. ANALISIS Para este programa se necesitan varias funciones de condición if para hacer la comparación y así poder imprimir los números en forma ascendente y para validar los números también otros if para que el número ingresado este el rango que se pedía en el programa DOCUMENTACION #include<stdio.h> LIBRERIAS #include<conio.h> int i,a,b,c,op; Declaración de variables Inicio de la función borde void borde() { for(i=1;i<=80;i++) { gotoxy(i,1);printf("±"); gotoxy(i,24);printf("±"); } Impresión del margen for(i=1;i<=24;i++) { gotoxy(1,i);printf("±"); gotoxy(80,i);printf("±"); } } void numero() Inicio de la función void main { do Inicio del do { gotoxy(24,4);printf(" "); Ingreso el primer numero gotoxy(15,4);printf("Numero 1; ");scanf("%d",&a); } while(a>64 || a<4); Si ese número cumple con la condición empleada pide el siguiente número do { gotoxy(24,5);printf(" Inicio del do "); Ingreso el segundo numero 96
  101. 101. gotoxy(15,5);printf("Numero 2: ");scanf("%d",&b); } Si ese número cumple con la condición while(b>64 || b<4); empleada pide el siguiente numero do Inicio del do { gotoxy(24,6);printf(" "); gotoxy(15,6);printf("Numero 3: ");scanf("%d",&c); Ingreso el tercer numero }while(c>64 || c<4); } void orden() Inicio de la función void orden { if(a<=b && a<=c) { if(b<=c) { gotoxy(15,8);printf("%d %d %d",a,b,c); } if(c<=b) { gotoxy(15,8);printf("%d %d %d",a,b,c); } } Proceso para presentar if(b<=a && b<=c) los números ingresados { en forma ordenada if(a<=c) ascendentemente. { gotoxy(15,8);printf("%d %d %d",b,a,c); } if(c<=a) { gotoxy(15,8);printf("%d %d %d",b,c,a); } } if(c<=a && c<=b) { if(a<=b) { gotoxy(15,8);printf("%d %d %d",c,a,b); } if(b<=a) { gotoxy(15,8);printf("%d %d %d",c,b,a); } 97
  102. 102. } gotoxy(15,7);printf("El orden es:"); } Inicio de la función principal void main() { do { Borrar pantalla clrscr(); borde(); Llamar al borde Llamar a la función numero Llamar a la función orden numero(); orden(); gotoxy(15,22);printf("Desea salir 1/0: ");scanf("%d",&op); } while(op==1); Si la opción ingresada por el usuario es igual a 1 el proceso se repetirá getch(); } Fin del programa CORRIDO DEL PROGRAMA 98
  103. 103. 34.- Diseñe un programa utilizando funciones que me permita generar y visualizar los números perfectos. ANALISIS    En este programa utilizamos la librería math porque utilizamos la función pow Utilizamos un do –while para que el usuario ingrese otro limite o quiera salir del programa Aquí también empleamos la utilización de las funciones DOCUMENTACION #include<stdio.h> LIBRERIAS #include<conio.h> #include<math.h> int i,r,dos=2,ex=1,ex2=2,s,v,l1,expo2=2, expo3=3,a,b,c,f=9,i,op; void borde() { for(i=1;i<=80;i++) { gotoxy(i,1);printf("*"); gotoxy(i,24);printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("*"); gotoxy(80,i);printf("*"); } } void perfecto(int l) { r=pow(dos,ex); s=pow(dos,ex2); v=r*(s-1); gotoxy(7,8);printf("%d",v); for(i=1;i<=l-1;i++) { a=pow(dos,expo2); Inicio de la función borde Impresión del margen Inicio de la función void perfecto Operaciones para sacar los números perfectos Operaciones para sacar los números perfectos 99 Declaración de variables
  104. 104. b=pow(dos,expo3); expo2=expo2+2; expo3=expo3+2; c=a*(b-1); gotoxy(7,f);printf("%d",c); f=f+1; } }//cierre del void Impresión de los números perfectos Inicio de la función principal void main() { do { f=9,dos=2,ex=1,ex2=2,expo2=2,expo3=3,f=9; Declaración de variables clrscr(); Borrar pantalla Llamar al borde borde(); gotoxy(30,4);printf("SERIE DE NUMEROS PERFECTOS"); gotoxy(5,6);printf("Ingrese un limite: ");scanf("%d",&l1); Llamo a la función perfecto Impresión del titulo Ingreso del limite perfecto(l1); gotoxy(50,22);printf(" "); gotoxy(4,22);printf("PRESIONE 1 PARA VOLVER AL MENU O 0 PARA SALIR: ");scanf("%d",&op); } while(op==1); Si la opción ingresada por el usuario es igual a 1 el proceso se repetirá getch(); } Fin del programa CORRIDO DEL PROGRAMA 100
  105. 105. 35.- Diseñe un programa utilizando funciones que me permita resolver un sistema de ecuación de 2° grado. ANÁLISIS Partiremos escribiendo la fórmula para tener base de que nomás se va a utilizar. La fórmula genera dos respuestas: Una con el signo más (+) y otra con el signo menos (−) antes de la raíz. Solucionar una ecuación de segundo grado se limita, entonces, a identificar las letras a, b y c y sustituir sus valores en la fórmula. La fórmula general para resolver una ecuación de segundo grado sirve para resolver cualquier ecuación de segundo grado, sea completa o incompleta, y obtener buenos resultados tiene que ver con las técnicas de factorización. CODIFICACIÓN #include <stdio.h> #include <stdlib.h> #include <conio.h> #include <math.h> int i,j,op; void borde() { textcolor(BLUE); for(i=1;i<=80;i++) { gotoxy(i,1);cprintf("*"); gotoxy(i,24);cprintf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i);cprintf("*"); gotoxy(80,i);cprintf("*"); } } void seg () { float a, b, c; float x1, x2; float x1real, x2real; Activation de Liberia // declaración de variables globales función del borde // impression de * // fin del ciclo for // fin de la function borde // function para la ecuacion // inicio de la function /* complejas 101 */
  106. 106. float x1imag, x2imag; /* Partes imaginarias soluciones complejas */ float discriminante; /* Presentacion */ system ("cls"); /* Borrado de la pantalla */ borde(); gotoxy(10,3);printf("RESOLUCION DE LA ECUACION DE SEGUNDO GRADOn"); gotoxy(2,4);printf("============================================== ================n"); gotoxy(10,5);printf("El programa soluciona la ecuación de segundo gradon"); gotoxy(10,6);printf(" 2 n"); gotoxy(10,7);printf("ax + bx + c = 0 n"); /* Petición de datos */ printf("Introduzca los coeficientes:n"); printf(" Coeficiente a: "); scanf("%f", &a); printf(" Coeficiente b: "); scanf("%f", &b); printf(" Coeficiente c: "); scanf("%f", &c); /* Cálculos y resultados */ discriminante = b*b - 4*a*c; // calculo de discriminate printf("n La ecuacionn"); printf(" %14dn", 2); printf(" %12gx + %gx + %g = 0n", a, b, c); // impresiones printf(" tiene por soluciones "); if (discriminante == 0) // sentencia si dis es = a 0 { // inicio de if printf(" una raiz real doblen"); // impresión x1 = x2 = -b / (2*a); // calculo printf(" x1 = %.2fn", x1); printf(" x2 = %.2fn", x2); // impresión en pantalla } // fin de if else if (discriminante > 0) //si dis es mayor a cero { // cálculos printf(" dos raices realesn"); x1 = (-b + sqrt(discriminante)) / (2*a); x2 = (-b - sqrt(discriminante)) / (2*a); // impresiones printf("x1 = %.2fn", x1); printf("x2 = %.2fn", x2); } Else // caso contrario { //impresión en pantalla printf("dos raíces complejas conjugadasn"); //cálculos x1real = x2real = -b / (2*a); x1imag = sqrt(-discriminante) / (2*a); x2imag = -sqrt(-discriminante) / (2*a); // impresiones 102
  107. 107. } } void main () { Do { printf("x1 = ( %.2f, %.2fi)n", x1real, x1imag); printf("x2 = ( %.2f, %.2fi)n", x2real, x2imag); //fin del ese // fin de la función // inicio del programa // llave de inicio //ciclo do // llave de inicio de do borde (); // funcion borde seg (); // funcion seg gotoxy(22,22);printf("desea continuar: ");scanf("%d",&op); // impresión en pantalla y lectura } while(op==1); getch(); //pausa } // fin del programa. Corrido del Programa 103
  108. 108. 38.- Diseñe un programa utilizando vectores y funciones que me permita ingresar datos a un vector y presentarlos en otro vector ANÁLISIS Primero ingresamos las librerías que vamos a utilizar en este programa en este caso son las dos principales la STDIO.H Y LA CONIO.H, después como es un programa con funciones declaramos la variable que vamos a utilizar globalmente. Después ingresamos una función con el nombre de borde para que nuestro programa se visualice con un borde. Luego realizamos el programa principal con un VOID MAIN () para que se abra el programa principal seguido con la llave { y declaramos las demás variables a realizar en el programa (int vector1[10],fila,op,lim;), después ponemos un do-while para que se repita el programa n veces y llamamos las funciones realizadas y realizamos el ingreso del límite para que podaos ingresar datos a una función y que luego se visualice. DOCUMENTACIÓN #include<stdio.h> Librerías que vamos a utilizar en el programa #include<conio.h> int i; Declaramos la variable global void borde() { for(i=1;i<=80;i++) { gotoxy(i,1); printf("*"); gotoxy(i,24); printf("*"); } Realizamos la función para que se pueda realizar un borde en nuestro programa for(i=1;i<=24;i++) { gotoxy(1,i); printf("*"); gotoxy(80,i); printf("*"); } } void main() { Realizamos el programa principal y declaramos la variables que vamos a utilizar en el programa principal 104
  109. 109. int vector1[10],fila,op,lim; do { clrscr(); borde(); gotoxy(25,3); printf("**VISUALIZAR DATOS VECTOR**"); Aquí damos un limite al vector para poder dar datos numéricos a un limita vector gotoxy(10,5); printf("INGRESE EL LIMITE==>"); scanf("%d",&lim); Ingresamos el limite fila=6; for(i=1;i<=lim;i++) { do { gotoxy(20,fila); printf(" "); Ingresamos los números para que se llene el vector previamente dado un limite gotoxy(20,fila); scanf("%d",&vector1[i]); } while(vector1[i]<3 || vector1[i]>23); Damos o validamos los datos que estén entre 3 y 23 fila=fila+1; } fila=6; for(i=1;i<=lim;i++) Aquí se visualiza el vector que ingresamos en otra posición { gotoxy(40,fila); printf("%d",vector1[i]); fila=fila+1; } gotoxy(10,20); printf("PRESIONE 1 PARA REPETIR EL PROGRAMA CASO CONTRARIO 0==>"); scanf("%d",&op); Ingresamos otra opción para ver si se repite el programa n veces } while(op); getch(); Visualiza la opción y da por terminado el programa } 105
  110. 110. 106
  111. 111. CORRIDO DEL PROGRAMA 107
  112. 112. 41.- Diseñe un programa utilizando vectores y un menú de opciones que me permita realizar las 4 operaciones básicas, estas son: suma, resta, multiplicación y división. ANALISIS En este programa se realizan las operaciones básicas que son la suma, resta, multiplicación y división utilizando un menú de opciones y con vectores, en donde tenemos que ingresar valores en dos vectores diferentes en el vector1 y vector2 para que vayan realizando las operaciones correspondiente teniendo en cuenta las condiciones plantedas que se dieron en la resta y división en donde el valor del vector1 debe ser mayor al valor del vector2 si no se cumple la condición no se realiza las operaciones y se imprime un mensaje. DOCUMENTACION #include<stdio.h> #include<conio.h> Ingreso las librerías #include<stdlib.h> int multivec[15],opc,divisionvec[15], restavec[15],i,op,col,fila,vector1[15],vector2[15], Declaración de variables sumavec[15],limite1; void borde() Función borde { for(i=1;i<=80;i++) { Este proceso es para realizar el borde gotoxy(i,1); printf("*"); gotoxy(i,24); printf("*"); } for(i=1;i<=24;i++) { gotoxy(1,i); printf("*"); gotoxy(80,i); printf("*"); } } void ingreso(int limite1) Función para ingresar los valores de los vectores 108
  113. 113. { col=12; fila=8; Ingresamos la posición en la cual se va a visualizar los vectores for(i=1;i<=limite1;i++) { Utilizamos el for para poder ingresar los valores del vector1 y vector2 al final vamos sumando fila para q vayan colocándose en las posiciones correctas, cerramos la laves del for y la llaves de la función ingreso. gotoxy(col,fila); scanf("%d",&vector1[i]); gotoxy(col+10, fila); scanf("%d",&vector2[i]); fila=fila+1; } } void suma(int limite1) Función para realizar la suma { Abrimos con una llave fila=8; Ingresamos el valor de la fila en la que va a empezar a visualizarse los datos del vector. for(i=1;i<=limite1;i++) { sumavec[i]=vector1[i]+vector2[i]; gotoxy(40,fila); printf("%d",sumavec[i]); fila=fila+1; } Utilizamos el for para poder ingresar los valores del vector1 y vector2, realizamos la operación en donde se suman los dos vectores e imprimimos el resultado, vamos sumando fila para las correctas posiciones cerramos el for y la función suma. } void resta(int limite1) { fila=8; Función para realizar la resta Abrimos con una llave Ingresamos el valor de la fila en la que va a empezar a visualizarse los datos del vector. 109

×