Programazion

Conceptos,
estructuras
básicas y ejercicios resueltos
dentro de la introducción al
lenguaje C++.

EL ARTE DE PROGRAMAR

DIEGO ROJAS
2013

INDICE:
INTRODUCCION………………………………………………………………………………………………………………………… 3
CAPITULO 1…………………………………………………………………………………………………………………………….. 4-5
CAPITULO2……………………………………………………………………………………………………………………………. 6-7
CAPITULO 3………………………………………………………………………………………………………………………… 8-9
CAPITULO 4…………………………………………………………………………………………………………………………
10
CAPITULO 5…………………………………………………………………………………………………………………………
11
CAPITULO 6………………………………………………………………………………………………………………………… 12-16
CAPITULO 7………………………………………………………………………………………………………………………… 17-18
CAPITULO 8…………………………………………………………………………………………………………………………
19
CAPITULO 9………………………………………………………………………………………………………………………… 20-21
CAPITULO 10………………………………………………………………………………………………………………………… 22-25

EJERCICIOS BASICOS CON LAS SENTENCIAS TRATADAS ANTERIORMENTE
(IF,DO,DO WHILE,FOR)
PROGRAMA N:1……………………………………………………………………………………………………….. 26-28
PROGRAMA N:2……………………………………………………………………………………………………….. 29-30
PROGRAMA N:3……………………………………………………………………………………………………… 31
PROGRAMA N:4…………………………………………………………………………………………………… 32
PROGRAMA N:5………………………………………………………………………………………………………33
PROGRAMA N:6………………………………………………………………………………………………………34-36
PROGRAMA N:7………………………………………………………………………………………………………37-39
PROGRAMA N:8………………………………………………………………………………………………………40-42
PROGRAMA N:9………………………………………………………………………………………………………43-45
PROGRAMA N:10……………………………………………………………………………………………………46-51
PROGRAMA N:11……………………………………………………………………………………………………52-53
PROGRAMA N:12……………………………………………………………………………………………………54-56
PROGRAMA N:13……………………………………………………………………………………………………57
PROGRAMA N:14……………………………………………………………………………………………………58-59
PROGRAMA N:15……………………………………………………………………………………………………60
PROGRAMA N:16……………………………………………………………………………………………………61-62
PROGRAMA N:17……………………………………………………………………………………………………63-65
PROGRAMA N:18……………………………………………………………………………………………………66-68
PROGRAMA N:19……………………………………………………………………………………………………69-70
PROGRAMA N:20……………………………………………………………………………………………………71-73
PROGRAMA N:21……………………………………………………………………………………………………74-75
PROGRAMA N:22……………………………………………………………………………………………………76-78
PROGRAMA N:23……………………………………………………………………………………………………79-81
PROGRAMA N:24……………………………………………………………………………………………………82-87
PROGRAMA N:25……………………………………………………………………………………………………88-95
PROGRAMA N:26……………………………………………………………………………………………………96-102

PROGRAMA N:27……………………………………………………………………………………………………103-107
PROGRAMA N:28…………………………………………………………………………………………………108-109
PROGRAMA N:29………………………………………………………………………………………………110-112
PROGRAMA N:30………………………………………………………………………………………………113-126
PROGRAMA N:31………………………………………………………………………………………………127-131
EJERCICIOS CON VECTORES Y MATRICES:
PROGRAMA N:32………………………………………………………………………………………………1132-134
PROGRAMA N:33………………………………………………………………………………………………135-137
PROGRAMA N:34………………………………………………………………………………………………138-139
PROGRAMA N:35………………………………………………………………………………………………140-147
PROGRAMA N:36………………………………………………………………………………………………148-152
PROGRAMA N:37………………………………………………………………………………………………153-157
PROGRAMA N:38………………………………………………………………………………………………158-160
PROGRAMA N:39………………………………………………………………………………………………161-164
PROGRAMA N:40………………………………………………………………………………………………165-171
PROGRAMA N:41………………………………………………………………………………………………172-175
PROGRAMA N:42………………………………………………………………………………………………175-177
PROGRAMA N:43………………………………………………………………………………………………178-183
PROGRAMA N:44………………………………………………………………………………………………184-186
PROGRAMA N:45………………………………………………………………………………………………187-189
PROGRAMA N:46………………………………………………………………………………………………190-195
PROGRAMA N:47………………………………………………………………………………………………195-201
PROGRAMA N:49………………………………………………………………………………………………201-206
PROGRAMA N:50………………………………………………………………………………………………206-210
PROGRAMA N:51………………………………………………………………………………………………211-214
PROGRAMA N:52………………………………………………………………………………………………215-217
PROGRAMA N:53………………………………………………………………………………………………218-221
PROGRAMA N:55………………………………………………………………………………………………222-226
PROGRAMA N:56………………………………………………………………………………………………226-228
PROGRAMA N:57………………………………………………………………………………………………228-231
PROGRAMA N:58………………………………………………………………………………………………231-233
PROGRAMA N:59………………………………………………………………………………………………233-238
PROGRAMA N:60………………………………………………………………………………………………238-241
LINCOGRAFIA…………………………………………………………………………………………………………………………242

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.
Este lenguaje ha sido estrechamente ligado al sistema operativo UNIX, puesto que fueron
desarrollados conjuntamente. Sin embargo, este lenguaje no está ligado a ningún sistema
operativo ni a ninguna máquina concreta. Se le suele llamar lenguaje de programación de
sistemas debido a su utilidad para escribir compiladores y sistemas operativos, aunque de
igual forma se puede desarrollar cualquier tipo de aplicación.
La base del C proviene del BCPL, escrito por Martin Richards, y del B escrito por Ken
Thompson en 1970 para el primer sistema UNIX en un DEC PDP-7. Estos son lenguajes
sin tipos, al contrario que el C que proporciona varios tipos de datos. Los tipos que ofrece
son caracteres, números enteros y en coma flotante, de varios tamaños. Además se pueden
crear tipos derivados mediante la utilización de punteros, vectores, registros y uniones. El
primer compilador de C fue escrito por Dennis Ritchie para un DEC PDP-11 y escribió el
propio sistema operativo en Introducción al lenguaje C (2).
La base del C proviene del BCPL, escrito por Martin Richards, y del B escrito por Ken
Thompson en 1970 para el primer sistema UNIX en un DEC PDP-7. Estos son lenguajes
sin tipos, al contrario que el C que proporciona varios tipos de datos. Los tipos que ofrece
son caracteres, números enteros y en coma flotante, de varios tamaños. Además se pueden
crear tipos derivados mediante la utilización de punteros, vectores, registros y uniones.
C trabaja con tipos de datos que son directamente tratables por el hardware de la mayoría
de computadoras actuales, como son los caracteres, números y direcciones. Estos tipos de
datos pueden ser manipulados por las operaciones aritméticas que proporcionan las
computadoras. No proporciona mecanismos para tratar tipos de datos que no sean los
básicos, debiendo ser el programador el que los desarrolle. Esto permite que el código
generado sea muy eficiente y de ahí el éxito que ha tenido como lenguaje de desarrollo de
sistemas. No proporciona otros mecanismos de almacenamiento de datos que no sea el
estático y no proporciona mecanismos de entrada ni salida. Ello permite que el lenguaje sea
reducido y los compiladores de fácil implementación en distintos sistemas. Por contra, estas
carencias se compensan mediante la inclusión de funciones de librería para realizar todas
estas tareas, que normalmente dependen del sistema operativo.
Muchas de las operaciones comunes con el sistema operativo se realizan a través de estas
funciones. Una colección de ficheros de encabezamiento, headers, en los que se definen los
tipos de datos y funciones incluidas en cada librería. Los programas que utilizan estas
bibliotecas para interactuar con el sistema operativo obtendrán un comportamiento
equivalente en otro sistema.
3

Capítulo 1.
Estructura básica de un programa en C.
La mejor forma de aprender un lenguaje es programando con
él. El programa más sencillo que se puede escribir en C es el
siguiente:
main ( )
{
}
Como nos podemos imaginar, este programa no hace nada, pero contiene la parte más
importante de cualquier programa C y además, es el más pequeño que se puede escribir y
que se compile correctamente. En el se define la función main, que es la que ejecuta el
sistema operativo al llamar a un programa C. El nombre de una función C siempre va
seguida de paréntesis, tanto si tiene argumentos como si no. La definición de la función está
formada por un bloque de sentencias, que esta encerrado entre llaves {}.
Un programa algo más complicado es el siguiente:
#include <stdio.h>
main ( )
{
printf ("Hola amigos!n");
}
Con el visualizamos el mensaje Hola amigos! en el terminal. En la primera línea indica que
se tengan en cuenta las funciones y tipos definidos en la librería stdio (standard
input/output). Estas definiciones se encuentran en el fichero header stdio.h. Ahora, en la
función main se incluye una única sentencia que llama a la función printf. Esta toma como
argumento una cadena de caracteres, que se imprimen van encerradas entre dobles comillas
" ". El símbolo n indica un cambio de línea.

4

Hay un grupo de símbolos, que son tratados como caracteres individuales, que especifican
Alerta
Espacio atrás
Salto de página
Salto de línea
Retorno de carro
Tabulación horizontal
Tabulación vertical
Barra invertida
Comilla simple
Comillas dobles
Visualiza un carácter cuyo código ASCII es OOO en octal
Visualiza un carácter cuyo código ASCII es HHH en
hexadecimal
algunos caracteres especiales del código ASCII. Los más importantes son:
a
b
f
n
r
t
v

'
"
OOO
xHHH

Un programa C puede estar formado por diferentes módulos o fuentes. Es conveniente
mantener las fuentes de un tamaño no muy grande, para que la compilación sea rápida.
También, al dividirse un programa en partes, puede facilitar la legibilidad del programa y
su estructuración. Las diferentes fuentes son compilados de forma separada, únicamente los
fuentes que han sido modificados desde la última compilación, y después combinados con
las librerías necesarias para formar el programa en su versión ejecutable.

5

Capítulo 2.
Tipos de datos y variables.
Una variable es un espacio de memoria
reservado en el ordenador para contener
valores que pueden cambiar durante la
ejecución de un programa. Los tipos que se
le asignen a estas determinan como se
manipulara la información contenida en
ellas.
Cada variable necesita un identificador que la distingue de las demás. Un identificador
válido es una secuencia de una o más letras, dígitos o guiones bajos, recordando que no
deben coincidir con palabras reservadas del lenguaje, deben comenzar por una letra y
además tomar en cuenta que C++ hace diferencia entre mayúsculas y minúsculas.
Las variables que se pueden presentar en un programa son de los siguientes tipos:
1. Variables Locales. Se definen solo en bloque en el que se vayan a ocupar, de esta
manera evitamos tener variables definidas que luego no se utilizan.
2. Variables Globales. No son lo más recomendable, pues su existencia atenta contra la
comprensión del código y su encapsulamiento.
3. Variables Estáticas. Se tienen que inicializar en el momento en que se declaran, de
manera obligatoria.
Ahora hablemos de los tipos de datos que reconoce C++. Estos definen el modo en que se
usa el espacio (memoria) en los programas. Al especificar un tipo de datos, estamos
indicando al compilador como crear un espacio de almacenamiento en particular, y también
como manipular este espacio. Un tipo de dato define el posible rango de valores que una
variable puede tomar al momento de ejecución del programa y a lo largo de toda la vida útil
del propio programa.
Los tipos de datos pueden ser predefinidos o abstractos. Un tipo de dato predefinido es
intrínsecamente comprendido por el compilador. En contraste, un tipo de datos definido por
el usuario es aquel que usted o cualquier otro programador crea como una clase, que
comúnmente son llamados tipos de datos abstractos.

6

Char

Carácter

(normalmente 8 bits)

Short

Entero corto con
signo


Int

Entero con signo

(depende de la
implementación)

Unsigned Entero sin signo

(depende de la
implementación)

Long

Entero largo con
signo


Float

Flotante simple


Double

Flotante doble


Las variables son definidas utilizando un identificador de tipo seguido del nombre de la
variable. Veamos el siguiente programa:
#include <stdio.h>
main ()
{
float cels, farh;
farh = 35.0;
cels = 5.0 * (farh - 32.0) / 9.0;
printf ("-> %f F son %f Cn", farh, cels);
}

En el programa anterior se definen dos variables float, se asigna un valor a la primera y se
calcula la segunda mediante una expresión aritmética. Las asignaciones en C también son
una expresión, por lo que se pueden utilizar como parte de otra expresión, pero según que
prácticas de este tipo no son muy recomendables ya que reducen la legibilidad del
programa. En la instrucción printf, el símbolo %f indica que se imprime un número en
coma flotante.
Hay un tipo muy importante que se representa por void que puede significar dos cosas
distintas, según su utilización. Puede significar nada, o sea que si una función devuelve un
valor de tipo void no devuelve ningún resultado, o puede significar cualquier cosa, como
puede ser un puntero a void es un puntero genérico a cualquier tipo de dato. Más adelante
veremos su utilización.

7

Capítulo 3.
Estructuras.
Una estructura es un grupo de variables relacionadas de manera lógica, las cuales pueden
ser de diferentes tipos y declaradas en una sola unidad, donde la unidad es la estructura.
¿Para que nos sirve? Las estructuras nos ayudan a agrupar datos de una manera más
ordenada y fácil para nosotros. Por ejemplo, supongamos que queremos guardar el nombre,
la edad y el número de teléfono de un contacto en un programa en C/C++.
Estas son una especie de hıbrido entre las estructuras de C y las clases de C++, de hecho
podrían ser sustituidas por clases definidas ya que disponen de tres tipos de modificadores
de acceso: público, privado y protegido, y el considerarlas como tales, permite un mayor
control de acceso de las estructuras.
En C++ se forma una estructura utilizando la palabra reservada STRUCT, seguida por un
campo etiqueta opcional, y luego una lista de miembros dentro de la estructura. La etiqueta
opcional se utiliza para crear otras variables del tipo particular de la estructura.

struct campo_etiqueta{
tipo_miembro miembro_1;
tipo_miembro miembro_2;
:
tipo_miembro miembro_n;
};

Un punto y coma finaliza la definición de una estructura puesto que esta es realmente una
sentencia C++.

Declaración de estructuras
Lo mismo que con el resto de las
clases , el proceso de usar una
estructura C++ comprende en
realidad tres pasos: definir la clase;
crear un objeto, e iniciar el objeto.

Definir la clase
En contra de lo que ocurre con el
resto de los tipos, que están predefinidos en el lenguaje. Por

8

ejemplo, al declarar char ch; ya se sabe exactamente que cosa es ch, en este caso hay que
definir previamente el tipo. Los tipos estructura se declaran mediante la palabra clave
struct. Sería algo así como:
Struct Punto;
struct Punt2 {int x; int y; int z; };
La primera sentencia es una declaración incompleta (ver más abajo); la segunda es una
definición completa de una nueva clase tipo struct denominado Punt2; tiene tres
componentes perfectamente definidos (tres int: x, y, z respectivamente). Como puede
verse, los componentes se determinan de forma análoga a los parámetros de las funciones,
determinando tipo y nombre. Aquí es imprescindible el punto y coma ";" para separar los
miembros (sin olvidar poner otro después del último).
Ya hemos señalado que en
C++ las estructuras son un
tipo de clases; entonces, si
nos referimos a la
terminología de la POO
diríamos que en esta fase
estamos definiendo la
clase. El conjunto de
declaraciones dentro de
los corchetes {...; ...; ...; }
declara los nombres y
tipos de sus miembros.
Los miembros pueden ser
de cualquier tipo con una
excepción:
Un miembro puede ser la
estructura que se declara
porque daría lugar a una
declaración circular (lo definido está dentro de su definición). Ejemplo:
struct mystr { mystr s };

// Ilegal

Uno, o varios, de los miembros puede ser un puntero a la estructura que se está declarando.
Ejemplo:
struct mystr { mystr *ps }

// Ok: Correcto

Nota: esta interesantísima posibilidad constituye la base de estructuras auto referenciadas;
una técnica de programación que tiene amplias posibilidades de aplicación. Por ejemplo,
listas enlazadas y árboles .

9

Capítulo 4.
Expresiones y operadores.
Los distintos operadores permiten formar expresiones tanto aritméticas como lógicas. Los
operadores aritméticos y lógicos son:
+, -

suma, resta

++, --

incremento, decremento

*, /, % multiplicación, división, módulo
>>, << rotación de bits a la derecha, izquierda.
&

AND booleano

|

OR booleano

^

EXOR booleano

~

complemento a 1

!

complemento a 2, NOT lógico

==, !=

igualdad, desigualdad

&&, ||

AND, OR lógico

<, <=

menor, menor o igual

>, >=

mayor, mayor o igual

En estos operadores deben tenerse en cuenta la precedencia de operadores y las reglas de
asociatividad, que son las normales en la mayoría de lenguajes. En la evaluación de
expresiones lógicas, los compiladores normalmente utilizan técnicas de evaluación rápida.
Para decidir si una expresión lógica es cierta o falsa muchas veces no es necesario evaluarla
completamente. Por ejemplo una expresión formada <exp1> || <exp2>, el compilador
evalúa primero <exp1> y si es cierta, no evalúa <exp2>. Por ello se deben evitar
construcciones en las que se modifiquen valores de datos en la propia expresión, pues su
comportamiento puede depender de la implementación del compilador o de la optimización
utilizada en una compilación o en otra. Estos son errores que se pueden cometer fácilmente
en C ya que una asignación es también una expresión.
Hay un tipo especial de expresión en C que se denomina expresión condicional y está
representada por los operadores? Su utilización es como sigue: <e>? <x>: <y>. Se evalúa si
e entonces x; si no, y.
int mayor (int a, int b ) {
return (a > b)? TRUE: FALSE;
}
waste_time () {
float a, b = 0.0;
( b > 0.0 ) ? sin(M_PI / 8) : cos(M_PI / 4);}

10

Capítulo 5.
Conversión de tipos.
Cuando escribimos una expresión
aritmética a+b, en la cual hay
variables o valores de distintos
tipos, el compilador realiza
determinadas conversiones antes
de que evalúe la expresión. Estas
conversiones pueden ser para
'aumentar' o 'disminuir' la
precisión del tipo al que se
convierten los elementos de la
expresión. Un ejemplo claro, es
la comparación de una variable
de tipo int con una variable de
tipo double. En este caso, la de
tipo int es convertida a double para poder realizar la comparación.
Los tipos pequeños son convertidos de la forma siguiente: un tipo char se convierte a int,
con el modificador signed si los caracteres son con signo, o unsigned si los caracteres son
sin signo. Un unsigned char es convertido a int con los bits más altos puestos a cero. Un
signed char es convertido a int con los bits más altos puestos a uno o cero, dependiendo del
valor de la variable.
Para los tipos de mayor tamaño:







Si un operando es de tipo double, el otro es convertido a double.
Si un operando es de tipo float, el otro es convertido a float.
Si un operando es de tipo unsigned long, el otro es convertido a unsigned long.
Si un operando es de tipo long, el otro es convertido a long.
Si un operando es de tipo unsigned, el otro es convertido a unsigned.
Si no, los operadores son de tipo int.

Una variable o expresión de un tipo se puede convertir explícitamente a otro tipo,
anteponiéndole el tipo entre paréntesis.
void cambio_tipo (void)
{
float a;
int b;
b = 10;
a = 0.5;
if ( a <=(float) b )
menor ();}

11

Capítulo 6.
Bloque de sentencias.
Las sentencias especifican y controlan el flujo de ejecución del programa. Si no existen
sentencias especıficas de selección o salto, el programa se ejecuta de forma secuencial en el
mismo orden en que se ha escrito el código fuente
.
En C++ el concepto de bloque de sentencias se utiliza para agrupar un conjunto de
sentencias dentro de un ámbito concreto dentro del programa. Un bloque de sentencias es
un conjunto de instrucciones englobadas bajo llaves { }.

Sentencia if
La sentencia if elige entre varias alternativas en base al valor de una o más expresiones
booleanas.
Sintaxis:
if( <expresión booleana>)
<bloque a ejecutar cuando la expresión es verdadera>
else
<bloque a ejecutar cuando la expresión es falsa>
La sentencia else es opcional, puede utilizarse o no. En el caso de no utilizarlo, cuando la
expresión evaluada sea falsa la ejecución continuará con la sentencia inmediatamente
posterior al if.

Comparaciones en C++
En C++ las comparaciones se especifican mediante el operador ==, en primera posición la
constante y como segundo miembro de la igualdad la variable. Dicha comparación nos
regresara un booleano.
if ( constante == variable){ }

Asignaciones en C++
En las asignaciones se debe evitar la conversión explicita de tipos de datos. Se aconseja no
hacer asignaciones múltiples, ya que estas dan a lugar a actuaciones erróneas. En general
las sentencias de asignación tienen la forma:
tipo variable;

12

variable = expresión;

Sentencia Switch
En casos en los que el programa presenta varias elecciones después de checar un expresión
múltiple o multi alternativa, donde el valor de una expresión determina que sentencias serán
ejecutadas es mejor utilizar una sentencia switch.
Esta estructura ocupa la palabra reservada break que permite que el flujo del programa se
detenga justo después de la ejecución de la sentencia anterior a ese break, pidiendo que se
ejecuten las sentencias correspondientes a las siguientes alternativas de switch.
Por otro lado default es opcional y engloba un conjunto de sentencias que se ejecutan en
caso de que ninguna de las alternativas del switch tenga un valor que coincida con el
resultado de evaluar la expresión del selector.
switch(var int o char)
{
case const1: instrucciones;
break;
case const2: instrucciones;
break;
default: instrucciones;
};

Sentencia For
La sentencia for se usara para definir un ciclo en el que
una variable se incrementa de manera constante en cada
iteración y la finalización del ciclo se determina mediante
una expresión constante. Como contador en for se
utilizaran preferiblemente variables de un solo carácter
como i, j, k, declarándolas dentro del mismo ciclo.
Su formato general es:
for (inicialización; condición; incremento)
{ instrucción (es); };

Sentencias While y do While
Al comenzar un ciclo while o do...while la expresión de control debe tener un valor
claramente definido, para impedir posibles indeterminaciones o errores de funcionamiento.

13

La sentencia while se usara para definir un ciclo en el que la condición de terminación se
evalúa al principio del mismo.

cargar o inicializar variable de condición;
while(condición)
{
grupo cierto de instrucciones;
instrucción(es) para salir del ciclo;
};

La sentencia do...while
Se usara para definir un ciclo en el que la condición de terminación se evaluara al final del
mismo.
cargar o inicializar variable de condición;
do {
grupo cierto de instrucción(es);
instrucción(es) de rompimiento de ciclo;
} while (condición);

Sentencia exit y return
La sentencia exit finaliza la ejecución de un proceso de
manera inmediata, forzando la vuelta al sistema
operativo. No se aconseja su utilización en cualquier
parte del código, siendo preferible controlar el flujo en
el proceso mediante bucles condicionales y devolver el
control mediante la sentencia return.
La sentencia return se utiliza para salir de una función o procedimiento, volviendo al punto
en el cual se llamó a dicha función o procedimiento. En el código hay que minimizar la
utilización de return, solo tendría que aparecer una vez en cada función o procedimiento, al
final del mismo, de manera que se tenga un solo punto de entrada a la función y un solo
punto de salida de la misma.

Sentencia break
La instrucción de salto break se usa para interrumpir (romper) la ejecución normal de un
bucle, es decir, la instrucción break finaliza la ejecución de un bucle y, por tanto, el control
del programa se transfiere (salta) a la primera instrucción después del bucle.

14

#include <stdio.h>
int main()
{
int n, a;
a = 0;
do
{
printf( "Introduzca un numero entero: " );
scanf( "%d", &n );
if ( n == 0 )
{
printf( "ERROR: El cero no tiene opuesto.n" );
break;
/* En el caso de que n sea un cero,
el bucle se interrumpe. */
}
printf( "El opuesto es: %dn", -n );
a += n;
} while ( n >= -10 && n <= 10 );
printf( "Suma: %d", a );
return 0;
}

16

Capítulo 7.
Funciones.
Un programa C está formado por un conjunto de funciones que al menos contiene la
función main. Una función se declara con el nombre de la función precedido del tipo de
valor que retorna y una lista de argumentos encerrados entre paréntesis. El cuerpo de la
función está formado por un conjunto de declaraciones y de sentencias comprendidas entre
llaves. Veamos un ejemplo de utilización de funciones:
#include <stdio.h>
#define VALOR 5
#define FACT 120
int fact_i (int v)
{
int r = 1, i = 0;
while (i <= v)
{
r = r * i;
i = i + 1;
}
return r;
}
int fact_r (int v)
{
if ( v == 0 ) return 1;
else return v * fact_r(v-1);
}
main() {
int r, valor = VALOR;
if ( (r = fact_i(valor)) != fact_r(valor) ) printf("Codificación errónea!!.n");
else if ( r == FACT ) printf("Codificación correcta.n");
else printf("Algo falla!!.n");
}

Se definen dos funciones, fact_i y fact_r, además de la función main. Ambas toman como
parámetro un valor entero y devuelven otro entero. La primera calcula el factorial de un
número de forma iterativa, mientras que la segunda hace lo mismo de forma recursiva.
Todas las líneas que comienzan con el símbolo # indican una directiva del pre compilador.
Antes de realizar la compilación en C se llama a un pre compilador cuya misión es procesar
el texto y realizar ciertas sustituciones textuales. Hemos visto que la directiva #include
incluye el texto contenido en un fichero en el fuente que estamos compilando. De forma
parecida, #define nombre texto sustituye todas las apariciones de nombre por texto. Así, en
el fuente, la palabra VALOR se sustituye por el número 5.

17

El valor que debe devolver una función se
indica con la palabra return. La evaluación de
la expresión debe dar una valor del mismo
tipo de dato que el que se ha definido como
resultado. La declaración de una variable
puede incluir una inicialización en la misma
declaración.
Se debe tener muy en cuenta que en C todos
los argumentos son pasados 'por valor'. No
existe el concepto de paso de parámetros 'por
variable' o 'por referencia'. Veamos un
ejemplo:
int incr ( int v ) { return v + 1; }
main() {
int a, b;
b = 3;
a = incr(b);
/* a = 4 mientras que b = 3. No ha cambiado
después de la llamada. */
}

En el ejemplo anterior el valor del parámetro de la función incr, aunque se modifique
dentro de la función, no cambia el valor de la variable b de la función main. Todo el texto
comprendido entre los caracteres /* y */ son comentarios al programa y son ignorados por
el compilador. En una fuente C los comentarios no se pueden anidar.

18

Capítulo 8.
Definición y prototipos de funciones.
Los programas sencillos, como los ejemplo planteados hasta ahora, normalmente no
necesitan un nivel de estructuración elevado. Pero cuando éstos crecen un poco
necesitamos estructurarlos adecuadamente para mantenerlos legibles, facilitar su
mantenimiento y para poder
reutilizar ciertas porciones de
código. El mecanismo C que
nos permite esto son las
funciones.
Con
los
compiladores, los fabricantes
nos
proporcionan
un
conjunto
importante
de
funciones de librería. A
veces, nos puede interesar
construir nuestras propias
librerías. Ya hemos utilizado
funciones, pero veamos
cómo debemos definirlas.
Los prototipos de funciones
son una característica clave
de la recomendación ANSI
del C. Un prototipo es una
declaración que toma la
forma:
tipo_resultado nombre_función (tipo_parámetro nombre_parámetro...);







int fact_i ( int v );
int mayor ( int a, int b );
int cero ( double a );
long raíz ( long valor );
void final_countdown ( void );
int main ( int argc, char **argv );

Observando el prototipo de una función podemos decir exactamente qué tipo de parámetros
necesita y que resultado devuelve. Si una función tiene como argumento void, quiere decir
que no tiene argumentos, al igual que si el resultado es void, no devuelve ningún valor.
En la vieja definición de Kernighan y Ritchie el tipo que devolvía una función se declaraba
únicamente si era distinto de int. Similarmente, los parámetros eran declarados en el cuerpo
de la función, en lugar de utilizar la lista de parámetros. Por ejemplo:

19

mayor ( a, b )
int a;
int b;
{
...
}
En un programa que esté formado por distintas partes bien diferenciadas es conveniente
utilizar múltiples ficheros fuente. Cada fuente agrupa las funciones semejantes, como por
ejemplo en un compilador podríamos tener un fuente para el análisis léxico, otro para el
sintáctico y otro para la generación de código. Pero en un fuente necesitaremos funciones
que se han definido en otro. Para ello, escribiremos, un fichero de cabecera (header), que
contendrá las declaraciones que podemos necesitar en otras fuentes. Así, en el fuente que
implementa el analizador sintáctico pondremos una línea #include "lexic.hx". De esta
forma al compilar el módulo sintáctico tendremos todos los prototipos de las funciones del
léxico y el compilador podrá detectar malas utilizaciones de las funciones allí definidas.

Capítulo 9.
Ámbito de funciones y variables.
El ámbito, o visibilidad, de una variable nos indica en que lugares del programa está activa
esa variable. Hasta ahora, en los ejemplos que hemos visto, se han utilizado variables
definidas en el cuerpo de funciones. Estas variables se crean en la memoria del ordenador
cuando se llama a la función y se destruyen cuando la función termina de ejecutarse. Es
necesario a veces, que una variable tenga un valor que pueda ser accesible desde todas las
funciones de un mismo fuente, e incluso desde otros fuentes.
En C, el ámbito de las variables depende de dónde han sido declaradas y si se les ha
aplicado algún modificador. Una variable definida en una función es, por defecto, una
variable local. Esto es, que sólo existe y puede ser accedida dentro de la función. Para que
una variable sea visible desde una función cualquiera de la misma fuente debe declararse
fuera de cualquier función. Esta variable sólo será visible en las funciones definidas
después de su declaración. Por esto, el lugar más común para definir las variables globales
es antes de la definición de ninguna función. Por defecto, una variable global es visible
desde otro fuente. Para definir que existe una variable global que está definida en otro
fuente tenemos que anteponer la palabra extern a su declaración. Esta declaración
únicamente indica al compilador que se hará referencia a una variable declarada en un
módulo distinto al que se compila.
Un modificador muy importante es const. Con él se pueden definir variables cuyo valor
debe permanecer constante durante toda la ejecución del programa. También se puede
utilizar con argumentos de funciones. En este caso se indica que el argumento en cuestión
es un parámetro y su valor no debe ser modificado. Si al programar la función,
modificamos ese parámetro, el compilador nos indicará el error.

20

#define EULER 2.71828
const double pi = 3.14159;
double lcercle (const double r )
{
return 2.0 * pi * r;
}
double EXP ( const double x )
{
return pow (EULER, x );
}
double sinh (const double x )
{
return (exp(x) - exp(-x)) / 2.0;
}
Debemos fijarnos que en el ejemplo anterior pi es una variable, la cual no podemos
modificar. Por ello pi sólo puede aparecer en un único fuente. Si la definimos en varios, al
linkar el programa se nos generará un error por tener una variable duplicada. En el caso en
que queramos acceder a ella desde otro fuente, debemos declararla con el modificador
extern.

21

CAPITULO 10.
Vectores y Matrices.
Un array (matriz o vector) es un conjunto finito y ordenado de elementos homogéneos. La
propiedad “ordenado” significa que el elemento primero, segundo y tercero,…, enésimo de
un array puede ser identificado. Los elementos del array son homogéneos, es decir, del
mismo tipo de datos. Los array también se conocen como matrices-en matemáticas- y
tablas- en cálculos financieros.
En otras palabras un arreglo es una especie de variable que contiene muchos valores pero
cada uno con una posición diferente. Un arreglo puede ser unidimensional o vectorial,
bidimensional o matricial, o multidimensional.

Vectores en C#
Qué es un vector? Un vector (o arreglo unidimensional) es una estructura de datos en la
cual se almacena un conjunto de datos de un mismo tipo. Es decir que un arreglo es una
lista de n elementos que posee las siguientes características:




Se identifica por un único nombre de variable
Sus elementos se almacenan en posiciones contiguas de memoria
Se accede a cada uno de sus elementos en forma aleatoria

22

MATRICES.
Son arreglos bidimensionales, es una colección finita, homogénea y ordenada de datos. Una
matriz está compuesta por filas y columnas, en la que se hace referencia a cada elemento
por medio de dos índices. El primero de los índices se utiliza para indicar la fila y el
segundo de los índices para indicar la columna.

Declaración de una matriz:
tipo_de_dato identificador [numFilas][numColumnas];;
Dónde:
tipo_de_dato: Es el tipo de datos que contendrá la matriz.

Identificador: Es el nombre que le damos a la variable matriz y por el cual la
referenciaremos en nuestro programa.
[numFilas][numColumnas] : Específica el número de Filas y de columnas que tendrá la
matriz

El espacio que las matrices ocupan en memoria se reserva en el momento de realizar la
declaración de los mismos.

23

Ejemplo:
int A[3][4];
// Declaración de una matriz de enteros de 3 filas y 4
columnas
float B[6][2]; // Declaración de una matriz de reales de 6 filas y 2
columnas
char C[4][10]; // Declamación de una matriz de caracteres de 4 filas y 10
columnas

Inicialización de una Matriz
Una matriz se pude inicializar para esto hay que agrupar entre {} cada fila. El formato a
utilizar sería el siguiente:
1
2
3
1
tipo_de_dato identificador[ filas ][ columnas ] = {

2

{ columnas de la fila 1 },

3

{ columnas de la fila 2 },

4

... ,

5

{ columnas de la última fila }

6

};

EJERCICIOS:
Que rellene un array con los 100 primeros números enteros y los muestre en pantalla
en orden descendente.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int x,tabla[100];
for (x=1;x<=100;x++)
{
tabla[x]=x;
}
24

for (x=100;x>=1;x--)
{
printf("%dn",tabla[x]);
}
system("PAUSE");
return 0;
}
Que lea 10 números por teclado, los almacene en un array y muestre la suma, resta,
multiplicación y división de todos.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int x,tabla[10];
int sum,res,mul,div;
for (x=0;x<10;x++)
{
printf("Introduzca númeron");
scanf("%d",&tabla[x]);
}
sum=tabla[0];
res=tabla[0];
mul=tabla[0];
div=tabla[0];
for (x=1;x<10;x++)
{
sum=sum+tabla[x];
res=res-tabla[x];
mul=mul*tabla[x];
div=div/tabla[x];
}
printf("Suma: %dn",sum);
printf("Resta: %dn",res);
printf("Multiplicación: %dn",mul);
printf("División: %dn",div);
system("PAUSE");
return 0;

25

EJERCICIOS RESUELTOS DURANTE EL PERIODO DE
CLASES CONDICIONES IF, WHILE, DO WHILE, FOR,
ETC:
1.- 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.


Análisis del Programa:

#include<stdio.h>
LIBRERIAS
#include<conio.h>
main ()
{
int a=1,b=0,oper;
VALIDACION DE LOS TERMINOS ESTABLECIDAS EN NUESTRO PROGRAMA
float c,p,v,s,t,f,g,r,q;
do
PROCESO DE REPETICION
{
clrscr();
LIMPIADO DE PANTALLA
a=1;
b=0;
gotoxy(30,2);printf("COMISIONES DE VENTAS");
IMPRIMO VALORES Y LOS HAGO VALIDOS
gotoxy(5,5);printf("Ingresar el valor de la venta:");
scanf("%f",&c);
if((c>2999)&&(c<5001))
DECISION SENTENCIA
{
IF
p=(c*5)/100;
v=c+p;
gotoxy(8,10);printf("La venta total es=%f",v);
PROCESOS
gotoxy(8,13);printf("La ganancia es=%f",p);
}
if((c>5000)&&(c<8499))
DECISION SENTENCIA
{
IF
s=(c*7)/100;
t=s+c;
gotoxy(8,10);printf("La venta total es=%f",t);
PROCESOS
gotoxy(8,13);printf("La ganancia es=%f",s);
}
if((c>8500)&&(c<10001))
DECISION SENTENCIA
{
IF
r=(c*8)/100;
q=r+c;
gotoxy(8,10);printf("La venta total es=%f",q);

26

gotoxy(8,13);printf("La ganancia es=%f",r);
}
if(c>10000)
DECISION SENTENCIA
{
IF
f=(c*10)/100;
g=f+c;
gotoxy(8,10);printf("La venta total es=%f",g);
PROCESOS
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();
CERRAMO EL
}
PROGRAMA


CERRAMOS PROCESO DE
REPETICION

DOCUMENTACION:

27

2.- Diseñe un programa que me permita ingresar un número entero desde teclado de 1
al 7, y que me permita visualizar el nombre del día de la semana que corresponda.



#include<stdio.h>
LIBRERIAS
#include<conio.h>
main ()
{
int d;
d=1;
clrscr();
gotoxy(10,2);printf("ingrese un dia de la semana");
scanf("%d", &d);
do
{
switch (d)
{
case 1:
gotoxy(10,5);printf("lunes");
break;
case 2:
gotoxy(10,5);printf("martes");
break;
case 3:
gotoxy(10,5);printf("miercoles");
break;
case 4:
gotoxy(10,5);printf("jueves");
break;
case 5:
gotoxy(10,5);printf("viernes");
break;
case 6:
gotoxy(10,5);printf("sabado");
break;
case 7:
gotoxy(10,5);printf("domingo");
break;
default:
gotoxy(10,5); printf("error");
}
} while (d<=7);

PROCESOS CASES

CERRAMOS PROCESO DE
REPETICION

getch();}
CERRAMO EL
PROGRAMA

29



CORRIDO DEL PROGRAMA:

3.-Diseñe un programa que me permita ingresar 2 números por teclado y realizar la
suma de los mismos.


ANALISIS DEL PROGRAMA

#include<conio.h>
LIBRERIAS
#include<stdio.h>
void main()
{
int n1, n2, tot;
clrscr();
gotoxy(33,3);printf("SUMA DE DOS NUMEROS");
gotoxy(5,5);printf("primer valor:");scanf("%d",&n1);
gotoxy(5,7);printf("segundo numero:");scanf("%d",&n2);
tot=n1+n2;
gotoxy(7,9);printf("la respuesta es = %d",tot);
getch();
CERRAMOS EL
}
PROGRAMA



DOCUMENTACION:

31




4.-Realice la suma de 2 números, siempre que el primer valor este entre 3 y 23, y el
segundo este entre 5 y 17.
#include<stdio.h>
#include<conio.h>
void main()
{

LIBRERIAS

int a,b,suma,op;
do
{
clrscr();
gotoxy(31,2); printf("suma de dos numeros");

32

do
{
gotoxy(37,5);printf(" ");
gotoxy(10,5); printf("ingrese el primer numero==>");scanf("%d",&a);
}while (a<3 || a>23);

IMPRIMO VALORES
Y LOS HAGO VALIDOS

do
{
gotoxy(37,7); printf(" ");
gotoxy(10,7); printf("ingrese el segundo numero==>");scanf("%d",&b);
}while (b<5 || b>17);
suma=a+b;

Y LOS HAGO VALIDOS

PROCESOS

gotoxy(10,9); printf("la suma es==>%d",suma);
gotoxy(10,11); printf("presione 1 para continuar o 0 para salir: ");scanf("%d",&op);
}while(op==1);
getch();
Cerramos EL
}
PROGRAMA



IMPRIMO VALORES

IMPRIMO
VALORES
Y LOS HAGO
VALIDOS

DOCUMENTACION:

33




6.-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



#include<stdio.h>
#include<conio.h>
main()

LIBRERIAS

34

{
clrscr();
int n1,n2,n3,p,s;
gotoxy(8,3); printf("promedios");
IMPRIMO VALORES
gotoxy(5,5); printf("ingrese la nota1: "); scanf("%d",&n1);
Y LOS HAGO VALIDOS
if(n1>10)
{
gotoxy(5,7);printf("nota incorrecta");
}
else
{
}
if(n2>10)
{
SENTENCIAS IF
}
else
{
}
if(n3>10)
{
}
s=n1+n2+n3;
PROCESOS
p=s/3;
gotoxy(5,17); printf("su pronedio es: %d",p );
if((p>=7)&&(p<=10))
{gotoxy(5,18);printf("Aprueba");}
if((p<=6)&&(p>=5))
{gotoxy(5,18); printf("Suspenso");}
if((p<=4)&&(p>=0))
{gotoxy(5,18); printf("Reprueba");}
getch();
}


Cerramos EL
PROGRAMA
DOCUMENTACION:

35




7.- 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.




#include<stdio.h>
LIBRERIAS
#include<conio.h>
#include<string.h>
void main()
{
int ed,op;
char nombre[15];
do
ABRIMOS EL DO
{
clrscr();
gotoxy(31,1);printf("Saber edad y equivalencia");
flushall();
IMPRIMO VALORES
gotoxy(10,3);printf("Ingrese nombre: ");gets(nombre);
Y LOS HAGO VALIDOS

37

do
{
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
SENTENCIAS IF
{
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);
CERRAMOS EL DO
getch();
}
Cerramos EL
PROGRAMA



DOCUMENTACION:

38



COFICICACION DEL PROGRAMA

8.- 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.

40




#include<stdio.h>
LIBRERIAS
#include<conio.h>
main()
{
int op,j,a=4,b=4,c=4,d=4,v=0;
VALIDACION DE LOS TERMINOS ESTABLECIDAS EN
float cant,vuni,vtotal,iva,s,sub,totalp;
NUESTRO PROGRAMA
char p[15];
clrscr();
gotoxy(23,1); printf("SIMULACION DE FACTURA");
IMPRIMO VALORES
gotoxy(5,4); printf("Producto");
Y LOS HAGO VALIDOS
gotoxy(20,4); printf("Cantidad");
gotoxy(34,4); printf("Precio Unitario");
gotoxy(55,4); printf("Valor");
do
ABRIMOS EL 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);
IMPRIMO VALORES
vtotal=cant*vuni;
LOS HAGO VALIDOS Y PROCESOS
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);
SENTENCIAS IF
}while(op==1);
CERRAMOS EL DO
j=v;
sub=j;
gotoxy(45,21); printf("subtotal: %.2f",sub);
iva=(sub*12)/100;
PROCESOS
gotoxy(50,22); printf("iva: %.2f",iva);
vtotal=sub+iva;
gotoxy(40,23); printf("valor a pagar: %.2f",vtotal);
getch();
Cerramos EL
}
PROGRAMA



DOCUMENTACION:

41



COFICICACION DEL PROGRAMA:

42

9.-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 deben estar entre 1 y 10.


ANALISIS:

#include<stdio.h>
LIBRERIAS
#include<conio.h>
main()
{
int c=5,n1,n2,n3,op;
VALIDACION DE LOS TERMINOS ESTABLECIDAS EN
float prom;
NUESTRO PROGRAMA
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");
IMPRIMO VALORES
gotoxy(5,8); printf("Matematica Basica");
Y LOS HAGO VALIDOS
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
ABRIMOS EL DO

43

{
c=c+1;
do
{
gotoxy(39,c);printf(" ");
gotoxy(39,c);scanf("%d",&n1);
}
while (n1>10);
do
{
gotoxy(49,c);scanf("%d",&n2);
}
while (n2>10);
do
{
gotoxy(60,c);scanf ("%d",&n3);
}
while (n3>10);

SENTENCIA WHILE Y
PROCESOS

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);
CERRAMOS EL DO
getch();
}



CERRAMOS EL PROGRAMA

DOCUMENTACION:

44




10.-Realice un programa en C++ que me permita obtener el liquido a recibir de un
empleado bajo los siguientes parámetros:
El empleado percibe un salario minimo vital el mismo que depende de su categoría,
existen 3 posibles alterantivas, este datos deberá ser ingresada al inicio del programa
conjuntamente con el nombre del empleado:
 Categoria 1
180,00
 Categoría 2
250,00
 Categoría 3
380,00
A este salario minimo 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
hujos 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 correspondientres de ingresos, egresos y total a recibir.
El programa se genera n veces.



#include<stdio.h>

LIBRERIAS

46

#include<conio.h>
main ()
{
float x=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;
VALIDACION DE LOS TERMINOS
ESTABLECIDAS EN NUESTRO PROGRAMA
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);
PROCESO DO
}
WHILE
while(c>3 || c<1);
VALIDANDO
gotoxy(2,11); printf("Cantidad de hijos registrados: "); scanf("%d",&h);
TERMINOS
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");
IMPRIMO VALORES Y
gotoxy(5,8); printf("**************************");
gotoxy(10,10); printf("Ingresos");
LOS HAGO VALIDOS
gotoxy(46,10); printf("Egresos");
gotoxy(5,12); printf("Sueldo nominal ");
if(c==1)
{
s=x;
gotoxy(21,12); printf("%.2f",s);
DECISION SENTENCIA
}
IF
if(c==2)
{
s=y;

47

}
if(c==3)
{
s=z;
}
iess=(s*i)/100;
gotoxy(38,12); printf("Seguro: ");
gotoxy(52,12); printf("%.2f",iess);

PROCESOS

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

DECISION SENTENCIA
IF

if (h<3)
{
b=(h*k);
}
in=(s+ex+b);
gotoxy(5,18); printf("Total Ingresos: ");
gotoxy(21,18);printf("%.2f",in);

PROCESOS

eg=(iess+dcto);
gotoxy(38,18);printf("Total Egresos: ");

48

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



SENTENCIA DO WHILE Y
PROCESOS

CERRAMOS EL
PROGRAMA

DOCUMENTACION :

49

11.- Diseñe un programa que me permita imprimir un borde de pantalla



#include<stdio.h>
#include<conio.h>
main()
{
int i,limite,fila=6,op;

LIBRERIAS


fila=6;
LIMPIADO DE PANTALLA
clrscr();
//bordes
for (i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
}

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

SENTENCIA FOR

SENTENCIA FOR

52

}
getch();
}

CERRAMOS EL
PROGRAMA



DOCUMENTACION



CORRIDO DEL PROGRAMA

53

12.- 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.



#include<stdio.h>
LIBRERIAS
#include<conio.h>
main()
{
int i,limite,fila=6,op;
do
{
fila=6;
clrscr();
LIMPIADOR DE PANTALLA
//bordes
for (i=1;i<=80;i++)
{
SENTENCIA FOR
}
for (i=1;i<=24;i++)
SENTENCIA FOR
{
}
//serie de pares
VALIDACION DE LOS
TERMINOS ESTABLECIDAS EN
gotoxy(5,2);printf("ingrese el limite: ");scanf("%d",&limite);
NUESTRO PROGRAMA
gotoxy(20,4);printf("Pares:");
for (i=2;i<=limite;i+=2)
{
gotoxy(23,fila);printf("%d",i);
fila=fila+1;
}
fila=6;
SENTENCIA FOR

gotoxy(42,4);printf("Impares:");
for (i=1;i<=limite;i+=2)
{
gotoxy(46,fila);printf("%d",i);
fila=fila+1;
}

54

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



CERRAMOS EL PROCESOS
DE REPETICION

CERRAMOS EL
PROGRAMA

DOCUMENTACION

55

13.- Realizar un programa y visualizar los números primos.


ANÁLISIS DEL PROGRAMA:

#include<stdio.h>
LIBRERIAS
#include<conio.h>
#include<string.h>
main()
VALIDACION DE LOS TERMINOS ESTABLECIDAS
{
EN NUESTRO PROGRAMA
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++)
{
SENTENCIA FOR
}
for(i=1;i<=24;i++)
{
SENTENCIA FOR
}
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)
{
DECISION SENTENCIA
cnt=cnt+1;
}
IF
}
if(cnt==2)
{
gotoxy(40,fla);printf("%d",i);
fla=fla+1;
}
CERRAMOS EL
}
PROGRAMA



CORRIDO DE PROGRAMA

57

14.- Diseñe un programa que me permita visualizar la factorial de un número

ingresado desde teclado.



#include<stdio.h>
LIBRERIAS
#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("*");
SENTENCIA FOR
}
for (i=1;i<=24;i++)
{
gotoxy(1,i); printf("*");

58

}
gotoxy(31,3);printf("FACTORIALES");
IMPRIMO VALORES Y LOS
gotoxy(15,7);printf("ingrese el limite: ");scanf("%d",&l);
HAGO VALIDOS
for (j=1;j<=l;j++)
{
SENTENCIA FOR
f=f*j;
Y SUS PROCESOS
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();
}


CERRAMOS EL
PROGRAMA

DOCUMENTACION

59

16.-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.



#include<stdio.h>
LIBRERIAS
#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("*");
SENTENCIA FOR
}
BORDE DE PANTALLA
for (i=1;i<=24;i++)
{
gotoxy(1,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("*");
SENTENCIA FOR
gotoxy(23,m); printf("%d",j);
Y PROCESOS DE LA TABLA DE
gotoxy(25,m); printf("=");
MULTUIPLICAR
gotoxy(27,m); printf("%d",n);
m=m+1;
}
CERRAMOS
gotoxy(8,22); printf("presione 1 para regresar o 0 para salir: ");scanf("%d",&op);
PROCESO DE
}
REPETICION
while (op==1);
getch();
}



CERRAMOS EL
PROGRAMA

DOCUMENTACION

61




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


#include<conio.h>
LIBRERIAS
#include<stdio.h>
main()
{
int i=0,j=0,lt,c,res=0,op=1,nc=0;
do
{
clrscr();

VALIDACION DE LOS TERMINOS ESTABLECIDAS EN NUESTRO
PROGRAMA


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

SENTENCIA FOR PARA
REALIZAR EL BORDE

63

for(i=1;i<=80;i++)
{
}
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++)
SENTENCIA FOR
{
for(j=1;j<=c;j++)
{
if(i%j==0)
{
nc=nc+1;
}
SENTENCIA IF
}
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);
CERRAMOS EL
getch();
}
PROGRAMA


VALIDACION DE LOS
TERMINOS
ESTABLECIDAS EN
NUESTRO PROGRAMA

CERRAMOS
PROCESO DE
REPETICION

DOCUMENTACION

64

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


#include<conio.h>
LIBRERIAS
#include<stdio.h>
void main()
{
int limite,i,fla,op;
do
{
clrscr();
for(i=1;i<=80;i++)
{
SENTENCIA FOR PARA
}
REALIZAR EL BORDE
for(i=1;i<=24;i++)
{
}
flushall();
gotoxy(25,5);printf("Series");
IMPRIMO VALORES Y
gotoxy(15,6);printf("Ingrese limite: ");scanf("%d",&limite);
LOS HAGO VALIDOS
fla=6;
66

for(i=2;i<=limite;i+=2)
{
gotoxy(20,fla+1);printf("%d",i);
fla=fla+1;
SENTENCIA FOR Y SUS
}
RESPECTIVOS PROCESOS
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);
CERRAMOS EL
getch();
}
PROGRAMA


CERRAMOS PROCESO DE
REPETICION

DOCUMENTACION

67




68

19.- 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.



#include<stdio.h>
LIBRERIAS
#include<conio.h>
void main ()
{
int i,l,j,c,d,s,p,op,fa;
do
{
clrscr();
for(i=1;i<=80;i++)
{
SENTENCIA FOR PARA
}
REALIZAR EL BORDE
for(i=1;i<=24;i++)
{
}
gotoxy(16,2);printf("SERIE DE NUMEROS NUMERADOR
IMPRIMO VALORES Y
CUALQUIER,DENOMINADOR IMPAR");
LOS
gotoxy(10,3);printf("Ingrse el limite: ");scanf("%d",&l);
HAGO VALIDOS
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);
SENTENCIA FOR Y SUS
d=d+2;
gotoxy(13,6+i);printf("%d",d);
gotoxy(9,6+i);printf("/");
}
CERRAMOS
gotoxy(10,20);printf("Desea continuar 1 caso contario 0: ");scanf("%d",&op);
PROCESO DE
}while(op==1);
REPETICION
getch();
CERRAMOS EL
}
PROGRAMA



DOCUMENTACION

69

20.- Realice un programa que me permita general la siguiente serie de datos:
N= 5
Factor impar como numerador
Factorial como denominador



#include<conio.h>
LIBRERIAS
#include<stdio.h>
void main()
{
int s,f,i,d,j,op;
float factorial;
do
{
clrscr();


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

SENTENCIA FOR PARA
REALIZAR EL BORDE

71

}
IMPRIMO VALORES Y
gotoxy(15,2);printf("SERIE DE NUMEROS CON NUMERADOR
LOS HAGO VALIDOS
IMPAR E FACTORIAL DENOMINADOR");
gotoxy(10,3);printf("Ingrse el limite: ");scanf("%d",&s);
do
{
PROCESO DE VALIDACION CON
DO WHILE
gotoxy(10,4);printf("ingrese el factor:");scanf("%d",&f);
} while(f%2==0);
factorial=1;
for(i=1;i<=s;i++)
{
SENTENCIA FOR Y SUS
factorial=factorial*i;
gotoxy(5,6+i);printf("%d",f);
f=f+2;
gotoxy(13,6+i);printf("%4.0f",factorial);
}
CERRAMOS
PROCESO DE
}while(op==1);
REPETICION
getch();
CERRAMOS EL
}
PROGRAMA



DOCUMENTACION

72

21.- Generar n elementos de la siguiente serie, cualquier factor ingresando desde
teclado como numerador, el denominador números pares



#include<stdio.h>
LIBRERIAS
#include<conio.h>
void main ()
{
int i,l,j,c,d,s,p,op,fa;
do
{
clrscr();
for(i=1;i<=80;i++)
{
SENTENCIA FOR PARA
REALIZAR EL BORDE
}
for(i=1;i<=24;i++)
{
}

74

gotoxy(16,2);printf("SERIE DE NUMEROS NUMERADOR
IMPRIMO VALORES Y
CUALQUIER,DENOMINADOR PAR");
gotoxy(10,3);printf("Ingrse el limite: ");scanf("%d",&l);
LOS HAGO VALIDOS
gotoxy(10,4);printf("ingrese el factor:");scanf("%d",&fa);
c=0;
d=0;
for(i=1;i<=l;i++)
{
SENTENCIA FOR Y SUS
c=c+3;
gotoxy(5,6+i);printf("%d",c);
d=d+2;
gotoxy(13,6+i);printf("%d",d);
}
CERRAMOS
PROCESO
}while(op==1);
DE REPETICION
CERRAMOS EL
getch();
}
PROGRAMA


DOCUMENTACION

75




22.- Genere una serie de datos que lleve por numerador el factorial y por
denominador la serie de Fibonacci.
#include<conio.h>
LIBRERIAS
#include<stdio.h>
main()
{
int i, limit, fibon=0, colum=5, b=1, c=0, fac=1, op;
do
{


76

fibon=0, colum=5, b=1, c=0, fac=1;
clrscr();
for(i=1;i<=80;i++)
{
SENTENCIA FOR PARA
}
REALIZAR EL BORDE
for(i=1;i<=24;i++)
{
}
gotoxy(17,3);printf("SERIE NUMERADOR FACTORIAL
Y DENOMINADOR FIBONACCI");
HAGO VALIDOS
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;
SENTENCIA FOR Y SUS
b=c;
c=fibon;
gotoxy(colum,8);printf("-");
gotoxy(colum,7);printf("%d",fac);
fac=fac*i;
colum=colum+5;
}
CERRAMOS
gotoxy(3,22);printf("PRESIONE 1 PARA REPETIR LA SERIE O 0 PARA
PROCESO
FINALIZAR>> ");scanf("%d",&op);
DE REPETICION
}
while(op==1);
getch();
CERRAMOS EL
}
PROGRAMA


DOCUMENTACION

77

23.- Genere la siguiente serie de datos primos en el numerador e impares en el
denominador.



#include<stdio.h>
#include<conio.h>
LIBRERIAS
#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();
gotoxy(16,3);printf("SERIE NUMERADOR PRIMOS DENOMINADOR IMPARES");
for(i=1;i<=80;i++)
{
}
SENTENCIA FOR PARA
for(i=1;i<=24;i++)
REALIZAR EL BORDE
{
}
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;
SENTENCIA FOR Y SU
for(j=1;j<=i;j++)
{
resul=i%j;
if(resul==0)
{
cot=cot+1;
}
}
if(cot==2)

79

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

DECISION SENTENCIA IF Y
SUS PROCESOS

}
gotoxy(3,23);printf("PRESIONE 1 PARA REPETIR EL PROCESO O 0 PARA
FINALIZAR: ");scanf("%d",&op);
}
while(op==1);
CERRAMOS EL
getch();
}
PROGRAMA



CERRAMOS
PROCESO DE
REPETICION

DOCUMENTACION

80

24.-Diseñe un programa que me presente un menú de opciones con las operaciones
básicas, estas son suma, resta, multiplicación, división y una opción para salir del
programa.



#include<conio.h>
#include<stdio.h>
LIBRERIAS
#include<stdlib.h>
#include<math.h>
void borde()
{
int i;
clrscr();


82

for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)
{
}
}
void main()
{
int op,col=8,l,i;
float a,p,nu,s,r,c,m,c1,di,d,dv,e;
clrscr();
do
{

SENTENCIA FOR PARA
REALIZAR EL BORDE

VALIDACION DE LOS TERMINOS ESTABLECIDAS EN NUESTRO
PROGRAMA

LLAMAMOS A LA FUNCION BORDE

borde();
gotoxy(32,3);printf("OPERACIONES BASICAS");
gotoxy(5,5);printf("1.Suma");
gotoxy(5,7);printf("2.Resta");
gotoxy(5,9);printf("3.Multiplicaci¢n");
gotoxy(5,11);printf("4.Divisi¢n");
PARA EMPEZAR HACER EL MENU
gotoxy(5,13);printf("5.Salir");
gotoxy(5,22);printf("Que opcion desea realizar: ");
scanf("%d",&op);
switch(op)
{
case 1:
clrscr();
borde();
SENTENCIA CASE, FOR Y LA
IMPRESIÓN DE SUS
gotoxy(33,3);printf("SUMA");
PROCESOS
gotoxy(5,5);printf("Cuantos numeros desea sumar: ");
scanf("%d",&l);
for(i=1;i<=l;i++)
{
gotoxy(5,6);printf("Ingrese los numeros: ");scanf("%f",&nu);
s=s+nu;

83

}
gotoxy(col,8);printf("La suma es = %f",s);
break;
case 2:
clrscr();
SENTENCIA CASE, FOR Y LA
IMPRESIÓN DE SUS
borde();
PROCESOS
gotoxy(33,3);printf("RESTA");
gotoxy(5,5);printf("Ingrese la primera cantidad: ");
scanf("%f",&c);
gotoxy(5,6);printf("Ingrese la segunda cantidad: ");
scanf("%f",&c1);
if(c<=c1)
{
r=c1-c;
gotoxy(col,12);printf("Resta = %f",r);
}
DECISION SENTENCIA
else
IF Y SUS PROCESOS
{
r=c-c1;
gotoxy(col,12);printf("Resta = %f",r);
}
CERRAMOS EL CASE
break;
case 3:
clrscr();
borde();
SENTENCIA CASE Y LA
gotoxy(32,3);printf("MULTIPLICACION");
IMPRESIÓN DE SUS
gotoxy(5,5);printf("Ingrese el producto 1: ");scanf("%f",&p);
PROCESOS
gotoxy(5,7);printf("Ingrese el producto 2: ");scanf("%f",&nu);
m=p*nu;
gotoxy(col,13);printf("Multiplicaci¢n = %f",m);
break;
CERRAMOS EL CASE
case 4:
clrscr();
borde();
gotoxy(35,3);printf("DIVISION");
gotoxy(5,5);printf("Ingrese el dividendo: ");scanf("%f",&dv);
SENTENCIA CASE Y LA
gotoxy(5,6);printf("Ingrese el divisor: ");scanf("%f",&di);
IMPRESIÓN DE SUS
d=dv/di;
PROCESOS
gotoxy(col,12);printf("La division = %f",d);
break;
case 5:

84

clrscr();
borde();
exit(0);
CERRAMOS EL CASE
break;
}
gotoxy(3,23);printf("1 PARA VOLVER AL MENU DE DATOS
0 PARA FINALIZAR: ");scanf("%d",&op);
}
while(op==1);
getch();
CERRAMOS EL
}
PROGRAMA


CERRAMOS PROCESO DE
REPETICION

DOCUMENTACION:

85




87

25.- Realice un menú en el cual se visualice las 6 operaciones básicas: suma, resta,
multiplicación, división, potenciación y radicación, con sus respectivas validaciones.



#include<conio.h>
#include<stdio.h>
LIBRERIAS
#include<stdlib.h>
#include<math.h>
void borde()
{
int i;
clrscr();
for(i=1;i<=80;i++)
{
}
SENTENCIA FOR PARA
for(i=1;i<=24;i++)
REALIZAR EL BORDE
{
}
}
void main()
88

{
int i,a,p,num,exp,resul,b,op,opc,aux=0,s1,s2,s3,s4,d,val,
sum,min,sus,res,mult1,mult2,pro,di,div,coc;
float resp,f;
do
{
clrscr();
{
borde();
gotoxy(20,3);printf("<>LAS SEIS OPERACIONES BASICAS>>");
gotoxy(10,5);printf("1.- SUMA");
gotoxy(10,7);printf("2.- RESTA");
gotoxy(10,9);printf("3.- MULTIPLICACION");
gotoxy(10,11);printf("4.- DIVISION");
HAGO VALIDOS
gotoxy(10,13);printf("5.- RAIZ CUADRADA");
PARA EMPEZAR HACER
gotoxy(10,15);printf("6.- POTENCIACION");
EL MENU
gotoxy(10,17);printf("7.- SALIR");
do
{
gotoxy(38,21);printf("
");
VALIDAR CON LA SENTENCIA
gotoxy(10,21);printf("Que opcion desea realizar>> ");
WHILE
scanf("%d",&op);
}while(op>7);
switch(op)
{
case 1:
do
{
clrscr();
borde();
gotoxy(33,3);printf("SUMA");
SENTENCIA CASE Y LA
gotoxy(5,5);printf("Ingrese la primera cantidad>>");scanf("%d",&s1);
IMPRESIÓN DE SUS
gotoxy(5,7);printf("Ingrese la segunda cantidad>>");scanf("%d",&s2);
PROCESOS
gotoxy(5,9);printf("Ingrese la tercera cantidad>>");scanf("%d",&s3);
gotoxy(5,11);printf("Ingrese la cuarta cantidad>>");scanf("%d",&s4);
sum=s1+s2+s3+s4;
gotoxy(12,13);printf("suma>> %d",sum);
gotoxy(12,17);printf("PRESIONE 1 PARA REPETIR
EL PROCESO O 0 PARA FINALIZAR: ");scanf("%d",&opc);
}while(opc==1) ;
break;
case 2:
do
{
clrscr();
borde();

CERRAMOS EL CASE

89

gotoxy(33,3);printf("RESTA");
gotoxy(5,5);printf("Ingrese el minuendo:");scanf("%d",&min);
do
{
gotoxy(5,9);printf("ingrse el sustraendo:");scanf("%d",&sus);
}while(min<sus);
res=min-sus;
gotoxy(25,12);printf("la resta es>> %d",res);
}while(opc==1) ;
CERRAMOS EL CASE
break;
case 3:
do
{
clrscr();
borde();
gotoxy(33,3);printf("MULTIPLICACION");
gotoxy(5,5);printf("ingrese el primer valor:");scanf("%d",&mult1);
gotoxy(5,7);printf("ingrese el segundo valor:");scanf("%d",&mult2);
pro=mult1*mult2;
gotoxy(12,11);printf("multiplicacion>> %d",pro);
}while(opc==1) ;
CERRAMOS EL CASE
break;
case 4:
do
{
clrscr();
borde();
gotoxy(33,3);printf("DIVISION");
gotoxy(5,5);printf("ingrese el dividendo:");scanf("%d",&di);
do
{
gotoxy(5,9);printf("ingrse el divisor:");scanf("%d",&div);
}while(di<div);
coc=di/div;
gotoxy(12,11);printf("respuesta>> %d",coc);
}while(opc==1) ;
break;
CERRAMOS EL CASE

SENTENCIA CASE Y LA
IMPRESIÓN DE SUS
PROCESOS

SENTENCIA CASE Y LA
IMPRESIÓN DE SUS
PROCESOS

SENTENCIA CASE Y LA
IMPRESIÓN DE SUS
PROCESOS

90

case 5:
do
{
clrscr();
borde();
gotoxy(33,3);printf("RAIZ CUADRADA");
gotoxy(5,5);printf("ingrese el valor:");scanf("%d",&val);
SENTENCIA CASE Y LA
resp=sqrt(val);
IMPRESIÓN DE SUS
gotoxy(12,11);printf("respuesta>> %f",resp);
PROCESOS
}while(opc==1) ;
break;
CERRAMOS CASE
case 6:
do
PROCESOS DE REPETICION
{
clrscr();
borde();
gotoxy(33,3);printf("POTENCIACION");
SENTENCIA CASE Y LA
IMPRESIÓN DE SUS
gotoxy(5,5);printf("ingrese la base:");scanf("%d",&b);
PROCESOS
gotoxy(5,7);printf("ingrese el numero a exponer:");scanf("%d",&exp);
resul=b;
for(i=1;i<=exp-1;i++)
{
PROCESO FOR
resul=resul*b;
Y PROCESOS
gotoxy(12,11);printf("respuesta>> %d",resul);
}
CERRAMOS PROCESO DE
REPETICION
}while(opc==1) ;
break;
CERRAMOS CASE
case 7:
exit;
SALIR TOTALMENTE DEL PROGRAMA
break;
}
}
CERRAMOS PROCESO DE
gotoxy(18,22);printf("DESEA VOLVER AL
REPETICION
MENU PRINCIPAL 1/0: ");scanf("%d",&aux);
}
while(aux==1);
getch();
CERRAMOS EL PROGRAMA
}

91




95

26.- Realice un menú de las áreas y perímetros de las 4 figuras básicas: circulo,
cuadrado, triangulo y rectángulo.



#include<conio.h>
#include<stdio.h>
LIBRERIAS
#include<stdlib.h>
void borde()
{
int i;
clrscr();
for(i=1;i<=80;i++)
{
SENTENCIA FOR PARA
}
REALIZAR EL BORDE
for(i=1;i<=24;i++)
{
}
}
void main()
{

96


int i, l,a,p, op,opc,aux=0,ba,al,l1,l2,l3,r,d;
ESTABLECIDAS
float pi=13.141516;
EN NUESTRO PROGRAMA
do
{
clrscr();
{
borde();
gotoxy(20,3);printf("<<AREAS Y PERIMETROS DE
LAS 4 FIGURAS BASICAS>>");
gotoxy(10,5);printf("1.- CUADRADO");
gotoxy(10,7);printf("2.- TRIANGULO");
gotoxy(10,9);printf("3.- RECTANGULO");
HAGO VALIDOS
gotoxy(10,11);printf("4.- CIRCULO");
PARA EMPEZAR HACER
gotoxy(10,13);printf("5.- Salir");
EL MENU
gotoxy(10,21);printf("Que opcion desea realizar>> ");
scanf("%d",&op);
switch(op)
{
case 1:
do
{
clrscr();
borde();
gotoxy(33,3);printf("CUADRADO");
gotoxy(5,5);printf("Ingrese el lado del cuadrado>> ");
SENTENCIA CASE Y LA
scanf("%d",&l);
IMPRESIÓN DE SUS
a=l*l;
PROCESOS
p=l+l+l+l;
gotoxy(12,7);printf("Area>> %d",a);
gotoxy(12,9);printf("perimetro>> %d",p);
gotoxy(12,17);printf("PRESIONE 1 PARA
REPETIR EL PROCESO O 0 PARA FINALIZAR: ");
scanf("%d",&opc);
CERRAMOS PROCESO DE
}while(opc==1) ;
break;
REPETICION
case 2:
do
{
clrscr();
borde();
gotoxy(33,3);printf("TRIANGULO");
gotoxy(5,5);printf("Ingrese la base:");scanf("%d",&ba);
SENTENCIA CASE Y LA
gotoxy(5,7);printf("ingrse la altura:");scanf("%d",&al);
IMPRESIÓN DE SUS
gotoxy(5,13);printf("ingrese lado a:"),scanf("%d",&l1);
PROCESOS
gotoxy(5,15);printf("ingrese lado b:"),scanf("%d",&l2);
gotoxy(5,17);printf("ingrese lado c:"),scanf("%d",&l3);
a=ba*al/2;

97

gotoxy(30,6);printf("Area>> %d",a);
p=l1+l2+l3;
gotoxy(20,21);printf("PRESIONE 1 PARA REPETIR EL
PROCESO O 0 PARA FINALIZAR: ");scanf("%d",&opc);
}while(opc==1) ;
CERRAMOS EL CASE
break;
case 3:
do
{
clrscr();
borde();
gotoxy(33,3);printf("RECTANGULO");
gotoxy(5,5);printf("ingrese la base:");scanf("%d",&ba);
gotoxy(5,7);printf("ingrese la altura:");scanf("%d",&al);
a=ba*al;
p=2*(ba+al);
gotoxy(12,11);printf("area>> %d",a);
}while(opc==1) ;
CERRAMOS PROCESO DE

SENTENCIA CASE Y LA
IMPRESIÓN DE SUS
PROCESOS

REPETICION

break;
case 4:
do
{
clrscr();
borde();
gotoxy(33,3);printf("circulo");
gotoxy(5,5);printf("ingrese el radio:");scanf("%d",&r);
gotoxy(5,7);printf("ingrese el diametro:");scanf("%d",&d);
a= pi*(r*r);
p= pi*d;
gotoxy(12,11);printf("area>> %d",a);

gotoxy(20,20);printf("PRESIONE 1 PARA
REPETIR EL PROCESO O 0 PARA FINALIZAR: ");
scanf("%d",&opc);
}while(opc==1);
break;
case 5:
exit;

SENTENCIA CASE Y LA
IMPRESIÓN DE SUS
PROCESOS

CERRAMOS PROCESO DE
REPETICION


98

break;
}
}
gotoxy(20,22);printf("DESEA VOLVER AL MENU PRINCIPAL 1/0:
");scanf("%d",&aux);
}
while(aux==1);
getch();
CERRAMOS EL
}
PROGRAMA



CERRAMOS PROCESO
DE REPETICION

DOCUMENTACION

99




102

27.- Realice un menú que me permita realizar las conversiones básicas de metro,
kilometro, hectómetro y decímetro.

#include<conio.h>
LIBRERIAS
#include<stdio.h>
#include<stdlib.h>
void borde()
{
int i;
clrscr();
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("±");
SENTENCIA FOR PARA
gotoxy(i,24);printf("±");
REALIZAR EL BORDE
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("±");
gotoxy(80,i);printf("±");
}
}
void main()
{
int op,col=8;

103

float km,nu,dam,hm,m;
clrscr();
do
{
borde();
gotoxy(32,3);printf("CONVERSIONES BASICAS");
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();
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);
break;
case 3:
clrscr();
borde();
gotoxy(33,3);printf("De Hectometros a M - Km - Dam");
km=nu*0.1;
m=nu*100;

HAGO VALIDOS
PARA EMPEZAR HACER
EL MENU

SENTENCIA CASE Y LA
IMPRESIÓN DE SUS
PROCESOS

SENTENCIA CASE Y LA
IMPRESIÓN DE SUS
PROCESOS

SENTENCIA CASE Y LA
IMPRESIÓN DE SUS
PROCESOS

104

dam=nu*10;
break;
case 4:
clrscr();
borde();
gotoxy(33,3);printf("De Metros a M - Km - Hm");
km=nu*0.001;
hm=nu*0.01;
SENTENCIA CASE Y LA
m=nu*10;
IMPRESIÓN DE SUS
PROCESOS
break;
case 5:
exit(0);
break;
}
gotoxy(3,23);printf("1 PARA VOLVER AL MENU DE DATOS 0 PARA FINALIZAR:
");scanf("%d",&op);
CERRAMOS PROCESO DE
}
REPETICION
while(op==1);
getch();
CERRAMOS EL
}
PROGRAMA



DOCUMENTACION

105




107

28.-Diseñe un programa que me permita realizar un borde utilizaciones funciones.
#include<stdio.h>
LIBRERIAS
#include<conio.h>
#include<stdlib.h>
int i;
void borde()
FUNCION BORDE
{
for(i=1;i<=80;i++)
{
SENTENCIA FOR PARA
}
REALIZAR EL BORDE
for(i=1;i<=24;i++)
{
}
}
void main ()
{
clrscr();
borde();
getch();
}



DOCUMENTACION

108




109

29.-Diseñe un programa utilizando funciones que me permita generar n numeros
naturales



#include<stdio.h>
LIBRERIAS
#include<conio.h>
int limite,op,i,fila,col;
void borde()
{
for (i=1;i<=80;i++)
{
}
SENTENCIA FOR PARA
for (i=1;i<=24;i++)
REALIZAR EL BORDE
{
}
}
void numeros(int limite1)
FUNCION NUMERO
{
fila=7;
col=10;
for(i=1;i<=limite1;i++)
{
gotoxy(col,fila);printf("%d",i);
fila=fila+1;
PROCESO FOR
if(fila==18)
Y PROCESOS
{
col=col+10;
fila=7;
}
}
}
void main()
{
do
{
clrscr();
LLAMADO FUNCION DE BORDE
borde();
gotoxy(10,4);printf("serie de numeros");
gotoxy(15,5);printf("ingrese el limite==>");scanf("%d",&limite);
numeros(limite); //variable del programa
LLAMADO DE LA FUNCION NUMERO

110

gotoxy(20,20);printf("presine 1 para continuar o 0 para salir==>");
scanf("%d",&op);
}
while(op==1);
getche();
CERRAMOS EL
}
PROGRAMA


CERRAMOS PROCESO DE
REPETICION

DOCUMENTACION

111




112

30.- Diseñe un programa utilizando funciones que me permita calcular el valor de las
comisiones por venta de vehículos según los siguientes condicionamientos, existen 3
vendedores, el vendedor 1, el vendedor 2, el vendedor 3, se asigna un valor de
comisión si:
 La venta es ≥ 8500 y ≤ 13500 la comisión es del 3%
 La venta es > 13500 y ≤ 18000 la comisión es del 8%
 La venta es > 18000 la comisión es del 11%
Obtenga el número de ventas realizadas por vendedor, el total de ventas realizadas, el
total de comisiones recibidas y el total general de todas las comisiones.



#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int i,op,fila,op1,op2,v=0;
float totalv,c,valor,a,b,d;

LIBRERIAS


void borde()
FUNCION BORDE
{
clrscr();
for(i=1;i<=80;i++)
{
}
SENTENCIA FOR PARA
for(i=1;i<=24;i++)
REALIZAR EL BORDE
{
}
}
FUNCION VENDEDOR
void vendedor()
{
gotoxy(10,5);printf("Ingrese el valor de la venta:");
gotoxy(5,7);printf("Cantidad:");
gotoxy(19,7);printf("Porcentaje:");
gotoxy(35,7);printf("Comision:");
fila=8;
totalv=0;

HAGO VALIDOS

113

do
{
fila=fila+1;
gotoxy(6,fila);scanf("%f",&valor);
if(valor<8500)
{
gotoxy(34,fila);printf("sin comision");
}
else
{
if(valor>=8500 && valor<=13500)
{
DECISION SENTENCIA IF Y SUS
gotoxy(19,fila);printf(" 3% ");
PROCESOS
c=valor*0.03;
CORRESPONDIENTES
gotoxy(37,fila);printf("%.2f",c);
}
else
{
if(valor>13500 && valor<=18000)
{
c=valor*0.08;
}
else
{
c=valor*0.11;
}
}
}
totalv=totalv+valor;
gotoxy(50,5);printf("Total Ventas: %.2f ",totalv);
v=v+1;
PROCESOS
gotoxy(50,7);printf("Numero Ventas: %d ",v);
a=a+c;
gotoxy(50,9);printf("Total Comisiones: %.2f ",a);
CERRAMOS PROCESO DE
gotoxy(10,22);printf("Desea ingresar otra venta 1 / Calcular 0 ==> ");
REPETICION
scanf("%d",&op1);

114

}while(op1==1);
}
FUNCION VENDEDOR
void vendedor2()
{

fila=8;
totalv=0;
do
{
fila=fila+1;
if(valor<8500)
{
}
else
{
if(valor>=8500 && valor<=13500)
{
c=valor*0.03;
}
else
{
if(valor>13500 && valor<=18000)
{
c=valor*0.08;
}
else
{
c=valor*0.11;

HAGO VALIDOS

DECISION SENTENCIA IF Y SUS
PROCESOS
CORRESPONDIENTES

115

}
}
}
v=v+1;
PROCESOS
b=b+c;
gotoxy(50,9);printf("Total Comisiones: %.2f ",b);
CERRAMOS PROCESO DE
REPETICION
scanf("%d",&op1);
}while(op1==1);
}
void vendedor3()
FUNCION VENDEDOR
{
HAGO VALIDOS
fila=8;
totalv=0;
do
{
fila=fila+1;
if(valor<8500)
{
}
SENTENCIA CASE Y LA
else
IMPRESIÓN DE SUS
{
PROCESOS
if(valor>=8500 && valor<=13500)
{
c=valor*0.03;
}
else
{
if(valor>13500 && valor<=18000)

116

{
c=valor*0.08;
}
else
{
c=valor*0.11;
}
}
}
v=v+1;
PROCESOS
d=d+c;
gotoxy(50,9);printf("Total Comisiones: %.2f ",d);
CERRAMOS PROCESO DE
REPETICION
scanf("%d",&op1);
}while(op1==1);
}
FUNCION COMISIONES
void comisiones()
{
gotoxy(31,3);printf("TOTAL DE COMISIONES");
gotoxy(15,6);printf("Comision del primer vendedor: ");
gotoxy(50,6);printf("%.2f",a);
gotoxy(15,8);printf("Comision del segundo vendedor: ");
gotoxy(15,10);printf("Comision del tercer vendedor: ");
gotoxy(50,10);printf("%.2f",d);
}
void main()
{
do
{
v=0;
totalv=0;

PROCESOS

117

clrscr();
borde();
gotoxy(31,3);printf("VENTAS DE VEHICULOS");
gotoxy(8,5);printf("1. Primer Vendedor");
gotoxy(8,7);printf("2. Segundo Vendedor");
HAGO VALIDOS
gotoxy(8,9);printf("3. Tercer Vendedor");
PARA EMPEZAR HACER
gotoxy(8,11);printf("4. Total Comisiones");
EL MENU
gotoxy(8,13);printf("5. Salir");
do
{
gotoxy(27,20);printf("
");
gotoxy(5,20);printf("Ingrese una opcion ==> ");scanf("%d",&op);
}while(op>5);
switch (op)
{
case 1:
clrscr();
CASE 1 Y LA LLAMADA DE
FUNCION VENDEDOR
borde();
gotoxy(31,3);printf("Primer Vendedor");
vendedor();
break;
case 2:
clrscr();
borde();
gotoxy(31,3);printf("Segundo Vendedor");
FUNCION VENDEDOR 2
vendedor2();
break;
case 3:
clrscr();
borde();
gotoxy(31,3);printf("Tercer Vendedor");
vendedor3();
FUNCION VENDEDOR 3
break;
case 4:
clrscr();
borde();
CASE 1 Y LA LLAMADA
gotoxy(31,3);printf("TOTAL DE COMISIONES GENERAL");
DE FUNCION
comisiones();
COMISIONES
break;

118

case 5:
exit(0);
break;
}
gotoxy(10,22);printf("Presiones 1 para volver al menu o 0 para salir ==>
");scanf("%d",&op2);
}while(op2==1);
getch();
CERRAMOS EL
}

CERRAMOS PROCESO
DE REPETICION

PROGRAMA



DOCUMENTACION

119




124

Programazion

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (19)

Ähnlich wie Programazion

Ähnlich wie Programazion (20)

Mehr von Diego Rojas

Mehr von Diego Rojas (9)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Programazion