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++)
{
SENTENCIA FOR
}
BORDE DE PANTALLA
for (i=1;i<=24;i++)
{
}
//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
REALIZAR EL BORDE
}
for(i=1;i<=24;i++)
{
gotoxy(1,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,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(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

31.- Diseñe un programa, que me permita ingresar 3 valores enteros entre 4 y 64 y
presentarlos en forma ordenada ascendentemente.



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

LIBRERIAS

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

SENTENCIA FOR PARA
REALIZAR EL BORDE

FUNCION VENDEDOR
void numeros()
{
do
{
gotoxy(10,5);printf("Ingrese el primer valor:");scanf("%d",&a);
}while(a<3||a>65);
do
{
gotoxy(10,7);printf("Ingrese el segundo valor:");scanf("%d",&b);
}while(b<3||b>65);
do
{
gotoxy(10,9);printf("Ingrese el tercer valor:");scanf("%d",&c);
}while(c<3||c>65);

VALIDAR CON LA SENTENCIA
WHILE

127

if(a>b && b>c)
{
gotoxy(10,12);printf("%d %d %d",c,b,a);
}
else
{
if(a>c && c>b)
{
gotoxy(10,12);printf("%d %d %d",b,c,a);
}
else
{
if(b>a && a>c)
{
gotoxy(10,12);printf("%d %d %d",c,a,b);
}
else
{
if(b>c && b>a)
{
gotoxy(10,12);printf("%d %d %d",a,c,b);
}
else
{
if(c>a && a>b)
{
gotoxy(10,12);printf("%d %d %d",b,a,c);
}
else
{
if(c>b && b>a)
{
gotoxy(10,12);printf("%d %d %d",a,b,c);
}
}
}
}
}
}
}
void main()
{

DECISION SENTENCIA
IF

do
{
clrscr();
128

borde();
gotoxy(31,3);printf("serie de numeros enteros");
numeros();
gotoxy(10,20);printf("presione 1 para continuar o 0 para salir");
scanf("%d",&op);
}while (op==1);
CERRAMOS EL
getch();
PROGRAMA
}


CERRAMOS PROCESO DE
REPETICION Y LLAMAMOS
LA FUNCION NUMEROS

DOCUMENTACION

129




131

32.-Diseñe un programa utilizando funciones que me permita resolver un sistema de ecuación
de 2° grado.



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

ANÁLISIS FLUJOGRAMICO:

#include <stdio.h>
#include <stdlib.h>
Activation de Liberia
#include <conio.h>
#include <math.h>
int i,j,op;
void borde()
Iniciamos los valores de
{
nuestro programa
textcolor(BLUE);
for(i=1;i<=80;i++)
{
gotoxy(i,1);cprintf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);cprintf("*");
}
}

Nuestro borde

void seg ()
// function
Función que ocuparemos
{
// inicio de
después
float a, b, c;
float x1, x2;
float x1real, x2real;
/* complejas */
float x1imag, x2imag;
/* Partes imaginarias soluciones complejas */
float discriminante;
/* Presentacion */
system ("cls");
/* Borrado de la pantalla */

132

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");
Etiquetas y procesos
2
n");
gotoxy(10,7);printf("ax + bx + c = 0
n");
del programa
printf("Introduzca los coeficientes:n");
printf(" Coeficiente a: "); scanf("%f", &a);
printf(" Coeficiente b: "); scanf("%f", &b);
printf(" Coeficiente c: "); scanf("%f", &c);
discriminante = b*b - 4*a*c;
printf("n La ecuacionn");
printf(" %14dn", 2);
printf(" %12gx + %gx + %g = 0n", a, b, c);
printf(" tiene por soluciones ");
if (discriminante == 0)
{
printf(" una raiz real doblen");
x1 = x2 = -b / (2*a);
printf(" x1 = %.2fn", x1);
printf(" x2 = %.2fn", x2);
}
else if (discriminante > 0)
{
printf(" dos raices realesn");
x1 = (-b + sqrt(discriminante)) / (2*a);
x2 = (-b - sqrt(discriminante)) / (2*a);
Sentencia if con sus
diferentes procesos y
printf("x1 = %.2fn", x1);
respuestas
printf("x2 = %.2fn", x2);
}
Else
{
printf("dos raíces complejas conjugadasn");
x1real = x2real = -b / (2*a);
x1imag = sqrt(-discriminante) / (2*a);
x2imag = -sqrt(-discriminante) / (2*a);
printf("x1 = ( %.2f, %.2fi)n", x1real, x1imag);
printf("x2 = ( %.2f, %.2fi)n", x2real, x2imag);
}
}
void main ()
{
comenzamos con la sentencia do
Do
{

133

borde ();
Llamamos a nuestra primera función
seg ();
borde
gotoxy(22,22);printf("desea continuar: ");scanf("%d",&op);
} while(op==1);
getch();
Pausado y cierre de programa
}

Cerramos la sentencia do
while la cual nos permitió
hacer una repetición


134

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 FLUJOGRAMICO:
#include<stdio.h>
#include<conio.h>
int i,a,b,c,op;

LIBRERIAS
Declaración de variables

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

Inicio del do
");

135

gotoxy(15,6);printf("Numero 3: ");scanf("%d",&c);
Ingreso el tercer numero
}while(c>64 || c<4);
}
Inicio de la función void orden
void orden()
{
if(a<=b && a<=c)
{
if(b<=c)
{
}
if(c<=b)
{
}
}
if(b<=a && b<=c)
{
if(a<=c)
{
gotoxy(15,8);printf("%d %d %d",b,a,c);
}
if(c<=a)
{
gotoxy(15,8);printf("%d %d %d",b,c,a);
}
}
if(c<=a && c<=b)
{
if(a<=b)
{
gotoxy(15,8);printf("%d %d %d",c,a,b);
}
if(b<=a)
{
gotoxy(15,8);printf("%d %d %d",c,b,a);
}
}
gotoxy(15,7);printf("El orden es:");
}
void main()
Inicio de la función principal
{

Proceso para presentar
los números ingresados
en forma ordenada
ascendentemente.

136

do
{
clrscr();
borde();

Borrar pantalla
Llamar al borde
Llamar a la función

numero();
orden();

Llamar a la función orden

}
while(op==1);
Si la opción ingresada por el usuario es igual a 1 el
proceso se repetirá
getch();
}

Fin del programa

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


137

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

#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()
Inicio de la función borde
{
for(i=1;i<=80;i++)
{
}
Impresión del margen
for(i=1;i<=24;i++)
{
}
}
Inicio de la función void
void perfecto(int l)
perfecto
{
r=pow(dos,ex);
Operaciones para sacar los
s=pow(dos,ex2);
números perfectos
v=r*(s-1);
gotoxy(7,8);printf("%d",v);
for(i=1;i<=l-1;i++)
{
a=pow(dos,expo2);
Operaciones para sacar los
b=pow(dos,expo3);
números perfectos
expo2=expo2+2;
expo3=expo3+2;
c=a*(b-1);
Impresión de los números
gotoxy(7,f);printf("%d",c);
perfectos
f=f+1;
}
}//cierre del void
void main()

Inicio de la función principal

138

{
do
{
f=9,dos=2,ex=1,ex2=2,expo2=2,expo3=3,f=9;


Borrar pantalla

clrscr();

Llamar al borde
borde();
gotoxy(30,4);printf("SERIE DE NUMEROS PERFECTOS");
gotoxy(5,6);printf("Ingrese un limite: ");scanf("%d",&l1);

Ingreso del limite

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

Fin del programa

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


139

35.- Diseñar un menú de opciones para:



Obtener la edad de una persona en años, meses y días.
Descomponga un número de 4 cifras en todos sus componentes posibles y presente la
sumatoria en la pantalla para obtener el mismo valor en la pantalla.

#include <conio.h>
#include <stdio.h>
Abrimos las librerías
#include<stdlib.h>
int i,op, d1, m1, a1, d2, m2, a2, d, m, a,a3,unidadm,c=0,d3,u;
void borde()
{
for(i=1;i<=80;i++)
{
Nuestro borde
}
for(i=1;i<=24;i++)
{
}
}
void edad()
{
después

nuestro programa

140

clrscr();
borde();
gotoxy(36,2);printf("EDAD");
gotoxy(5,6);printf("Ingrese dia actual: "); scanf("%d",& d1);
gotoxy(5,8);printf("Ingrese mes actual: "); scanf("%d",& m1);
gotoxy(5,10);printf("Ingrese a¤o actual: "); scanf("%d",& a1);
gotoxy(5,12);printf("Ingrese dia nacimineto: "); scanf("%d",& d2);
gotoxy(5,14);printf("Ingrese mes nacimineto: "); scanf("%d",& m2);
gotoxy(5,16);printf("Ingrese a¤o nacimineto: "); scanf("%d",& a2);
if (d1>=d2) {
d=d1-d2; }
else {
m1=m1-1;
d1=d1+30;
d=d1-d2;
}
if (m1>=m2)
{
m=m1-m2;
}
else
{
a1=a1-1;
m1=m1+12;
m=m1-m2;
}
a=a1-a2;

Ingresando y
haciendo validar los
datos

Sentencia if y sus
respectivos procesos

gotoxy(15,20);printf("Tu tienes ");
printf("%d", a); printf(" a¤os con "); printf("%d", m);
printf(" meses y "); printf("%d", d); printf(" dias");
}
void descompo()
{
despues
gotoxy(28,2);printf("Descomposicion de un numero");
gotoxy(22,4);printf("Ingrese el Valor: ");scanf("%d",&a3);
unidadm=a3;
unidadm=(unidadm/1000)*1000;
gotoxy(12,6);printf("Unidad de mil es: %d",unidadm);
c=a3;
c=c-unidadm;
c=(c/100)*100;
gotoxy(12,8);printf("Centena es: %d",c);
d3=a3;
d3=d3-unidadm-c;
d3= (d3/10)*10;
gotoxy(12,10);printf ("Decena es: %d",d3);
u=(a3-unidadm)-c-d3;
gotoxy(12,12);printf("Unidades es %d",u);

Procesos y
resultados

Ingresando y haciendo
validar los datos y
respuestas con sus
respectivos procesos

141

}
void main()
{
do
Procesos de repetición
{
clrscr();
borde();
gotoxy(28,3);printf("MENU DE OPCIONES");
gotoxy(15,6);printf("1.- Edad de una Persona....!");
gotoxy(15,8);printf("2.- Descomposicion de un Numero....!");
gotoxy(15,22);printf("ingrese la opcion que desea visualizar: ");
scanf("%d",&op);
switch(op)
{
case 1:
clrscr();
borde();
edad();
break;
case 2:
Cases y sus respectivas
clrscr();
funciones
borde();
descompo();
break;
case 3:
exit(0);
break;
}
gotoxy(15,22);printf("Ingrese 1 para continuar o 0 para salir: ");
scanf("%d",&op);
}
while(op==1);
getch();
Pausado i salida del programa
}

Menú de opciones

Cierro el ciclo repetitivo

ANALISIS :



Primero comenzamos haciendo nuestro borde y guardándole en una función.
Realizo mi primer programa el de la edad de una persona en años, meses y días
comenzando a validar mis datos, y realizo los procesos correspondientes que me
servirán para calcular los días y los meses, teniendo en cuenta que si son los días
de nacimiento son mayores que los de hoy debemos ir pidiendo prestados en
este caso a los meses y así los vamos restando y dándonos cuenta las respuestas
que nos deben ir quedando iguales o fáciles de resolver.
142





En el segundo programa que es una descomposición de los números lo único que
vamos realizando es irlo dividiendo para unidades de mil (1000), decenas (10),
centenas (100) y las unidades que se les va restando de acuerdo a los valores ya
obtenidos.
Todo esto unimos en un menú de opciones en el cual cada uno estará dentro de
un case y en este la función con la que empezamos a realizar el programa, que es
una forma más sencilla para no complicarnos en la utilización de variables
procesos y respuestas.

DOCUMENTACION DEL PROGRAMA:

143

36.-Diseñe un menú de opciones utilizando funciones que me permita diseñar 4 estilos de bordes
diferentes.

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
int op;
nuestro programa
void borde()
{
int i;
clrscr();
for(i=1;i<=80;i++)
{
Nuestro primer borde simple
}
for(i=1;i<=24;i++)
{
}
}
void bsim()
después
{
int i;
clrscr();
gotoxy(1,1);printf("Ú");
gotoxy(80,1);printf("¿");
for(i=2;i<=79;i++)
{
gotoxy(i,1);printf("Ä");
gotoxy(i,24);printf("Ä");
}
Nuestro segundo borde
gotoxy(1,24);printf("À");
simple
gotoxy(80,24);printf("Ù");
for(i=2;i<=23;i++)
{
gotoxy(1,i);printf("³");
gotoxy(80,i);printf("³");
}
}
void bdob()
{
después
int i;
Borrado de pantalla
clrscr();

148

gotoxy(1,1);printf("É");
gotoxy(80,1);printf("»");
for(i=2;i<=79;i++)
{
gotoxy(i,1);printf("Í");
}
Nuestro tercer borde
gotoxy(1,24);printf("È");
simple
gotoxy(80,24);printf("¼");
for(i=2;i<=23;i++)
{
gotoxy(1,i);printf("º");
}
}
void ep()
después
{
int i;
Borrado de pantalla
clrscr();
for(i=2;i<=79;i++)
{
gotoxy(i,3);printf("ù");
gotoxy(i,21);printf("ù");
Nuestro cuarto borde
}
simple
for(i=2;i<=23;i++)
{
}
}
void lucho()
después
{
int i;
Borrado de pantalla
clrscr();
gotoxy(1,1);printf("þ");
for(i=2;i<=79;i++)
{

149

gotoxy(i,1);printf("þ");
gotoxy(i,24);printf("þ");
}
Nuestro quinto borde
simple
for(i=2;i<=23;i++)
{
gotoxy(1,i);printf("þ");
gotoxy(80,i);printf("þ");
}
Comenzaremos con el
}
programa principal
void main()
{
do
Abrimos la Sentencia do
{
clrscr();
Borrado de pantalla y llamado de la función borde
borde();
gotoxy(30,3);printf("<<ESTILOS DE BORDES_GATO>>");
gotoxy(5,5);printf("1.- Borde simple>>");
gotoxy(5,7);printf("2.- Borde doble>>");
gotoxy(5,9);printf("3.- Encabezado y pie de pagina>>");
gotoxy(5,11);printf("4.- Borde <<Lucho's>>");
gotoxy(5,13);printf("5.- Salir>>");
do
{
gotoxy(5,15);printf("Que desea realizar>> ");scanf("%d",&op);
}
while(op>5);
switch(op)
{
case 1:
clrscr();
bsim();
gotoxy(30,10);printf("<<BORDE SIMPLE>>");
break;
case 2:
clrscr();
bdob();
gotoxy(30,10);printf("<<BORDE DOBLE>>");
break;
case 3:
clrscr();
ep();
gotoxy(30,10);printf("<<ENCABEZADO Y PIE>>");
break;
case 4:

Impresión del menu para
visualizar nuestros
distintos bordes

Diferentes cases para
abrir nuestros distintos
bordes

150

clrscr();
lucho();
gotoxy(30,10);printf("<<LUCHO'S>>");
break;
case 5:
exit(0);
break;
}
gotoxy(3,22);printf("PRESIONE 1 PARA VOLVER
A REPETIR EL PROCESO O 0 PARA FINALIZAR>> ");
scanf("%d",&op);
}
while(op==1);
getch();
}


ANALISIS:
Creo un menú con opciones para crear los distintos estilos de borde. La primera opción será
de un borde simple, la segunda de un borde doble, la tercera de un borde con encabezado, y
la cuarta un borde al gusto del programador. Para realizar los distintos estilos de borde
utilizamos los códigos ASCII.

151

37.- Diseñe un programa utilizando vectores y funciones que me permita ingresar datos a
un vector y presentarlos en otro vector
#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++)
{
}

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

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

153

}
}
void main()
Realizamos el programa principal y declaramos la
variables que vamos a utilizar en el programa principal

{
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(" ");
gotoxy(20,fila); scanf("%d",&vector1[i]);

Ingresamos los números para que se llene
el vector previamente dado un limite

}
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

154

{
gotoxy(40,fila); printf("%d",vector1[i]);
fila=fila+1;
}
gotoxy(10,20); printf("PRESIONE 1 PARA REPETIR EL PROGRAMA CASO CONTRARIO
0==>");
Ingresamos otra opción para ver si se repite el programa n veces

scanf("%d",&op);
}
while(op);

Visualiza la opción y da por terminado el programa

getch();

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

155

38.- Diseñe un programa utilizando vectores y funciones que me permita validar los datos de
entrada de un vector y presentarlos en un vector resultante

#include<stdio.h>
#include<conio.h>
int vector1[10],i,fila,limite;
void borde()
{
for (i=1;i<=80;i++)
{
}
borde
for (i=1;i<=24;i++)
{
}
}
void vector()
{
Ingrese el limite
gotoxy(24,6);printf("ingrese el limite==> ");scanf("%d",&limite);
fila=8; inicializazion de la variable(desde que punto va el vector)
for(i=1;i<=limite;i++)
ingreso un limite (n)
{
do
Validar una variable
{
gotoxy(25,fila);printf(" "); borrado de espacios tomando en cuenta la columna
gotoxy(25,fila);scanf("%d",&vector1[i]);
}while(vector1[i]<3 || vector1[i]>23); cierro do while aciendolo validar
fila=fila+1; siempre ira esto para k vayan los numerous uno sobre otro
}
fila=8;
{
gotoxy(45,fila);printf("%d",vector1[i]);
fila=fila+1;
}
Repito el mismo proceso
}
para imprimir en el otro
main()
lado
{
clrscr();
gotoxy(28,3);printf("presentacion del vector");
borde();
vector();
getch();

158

}

ANÁLISIS





luego se visualice.


159

39.- Diseñe un programa utilizando vectores y funciones que me permita sumar los datos
ingresados y validados de un vector y presentar la sumatoria en un vector resultante.

#include<stdio.h>
#include<conio.h>
int aux,vector1[10],vector2[10],sum[20],i,fila,limite,col=10;
void borde()
{
for (i=1;i<=80;i++)
{
}
borde
for (i=1;i<=24;i++)
{
}

161

}
void ingreso(int limite)
{
borde();
fila=10; (siempre inicializo par air contando las filas)
{
gotoxy(col,fila);scanf("%d",&vector1[i]); (primer vector ingresado)
gotoxy(col+20,fila);scanf("%d",&vector2[i]); (Segundo vector ingresado)
fila=fila+1; (par air contando las filas acia abajo)
}
}
void suma(int limite)
{
borde();
fila=10;
{
sum[i]=vector1[i]+vector2[i]; (proceso de la suma)
gotoxy(55,fila);printf("%d",sum[i]); (impression de la suma)
fila=fila+1;
}
}
main()
{
do
{
clrscr();
gotoxy(28,3);printf("SUMA DE DOS VECTORES");
gotoxy(24,6);printf("ingrese el limite==> ");scanf("%d",&limite); (ingreso el limite siempre aca
para sumar)
gotoxy(10,8);printf("1er vector");
gotoxy(30,8);printf("2do vector");
gotoxy(50,8);printf("suma de vectores");
borde();
ingreso(limite);
suma(limite);
getch();
gotoxy(18,22);printf("DESEA continuar 1/0: ");scanf("%d",&aux); (repeticion)
}
while(aux==1);
}

162

ANÁLISIS





luego se visualice.


163

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

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

Ingreso las
librerías

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

Declaración de
variables

void borde()
Función borde
{
for(i=1;i<=80;i++)
{
Este proceso es
para realizar el
}
borde
for(i=1;i<=24;i++)
{
}
}
Función para ingresar los valores
void ingreso(int limite1)
de los vectores
{
col=12;
Utilizamos el for para poder ingresar los
fila=8;
valores del vector1 y vector2 al final
{
vamos sumando fila para q vayan
gotoxy(col,fila); scanf("%d",&vector1[i]);
colocándose
en
las
posiciones
gotoxy(col+10, fila); scanf("%d",&vector2[i]);
correctas, cerramos la laves del for y la
fila=fila+1;
llaves de la función ingreso.
}
}
void suma(int limite1)
Función para realizar la suma
{
fila=8;
{
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.

165

}
void resta(int limite1)
{

Función para realizar la resta

fila=8;

{
if(vector1[i]>=vector2[i])
{
restavec[i]=vector1[i]-vector2[i];
gotoxy(40,fila); printf("%d",restavec[i]);
}
else
{
gotoxy(40,fila); printf("NO SE PUEDE CALCULAR");
}
fila=fila+1;
}
}
void multi(int limite1)
Función para realizar la
{

Utilizamos el for para poder ingresar
los valores del vector1 y vector2,
luego se utiliza un if para indicar que
el vector1 debe ser mayor que el
vector2 si la condición se cumple
realizamos la operación en donde se
resta los valores del vector que sea
mayor e imprimimos el resultado,
cerramos el if y si no se cumple la
condición escribimos un mensaje y
no se realiza la operación, cerramos
la llaves y vamos sumando fila para
las correctas posiciones cerramos el
for y la función resta.

multiplicación

fila=8;

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

{
multivec[i]=vector1[i]*vector2[i];
gotoxy(40,fila); printf("%d",multivec[i]);
fila=fila+1;
}
}
void division(limite1)
Función para realizar la división.
{
fila=8;
{
if(vector1[i]>=vector2[i])
{
divisionvec[i]=vector1[i]/vector2[i];
gotoxy(40,fila); printf("%d",divisionvec[i]);
}
else
{
gotoxy(40,fila);

valores del vector1 y vector2, luego se utiliza
un if para indicar que el vector1 debe ser
mayoro igual que el vector2 si la condición se
cumple realizamos la operación en donde se
dividen los valores del vector que sea mayor
e imprimimos el resultado, cerramos el if y si
no se cumple la condición escribimos un
mensaje y no se realiza la operación,
cerramos la llaves y vamos sumando fila
para las correctas posiciones cerramos el for
y la función división.

printf("NO SE PUEDE CALCULAR");
}
fila=fila+1;
}
Función principal del programa. Abrimos
}
con una llave
void main()
{
do
Utilizamos el ciclo do while para que el proceso se
{

repita tantas veces desee el usuario

clrscr();
Limpia la pantalla. Llama a la función borde.
borde();
gotoxy(15,3); printf("**OPERACIONES CON VECTORES Y FUNCIONES**");
gotoxy(10,5); printf("1.-SUMA");
gotoxy(10,7); printf("2.-RESTA");
Diseño de pantalla.
gotoxy(10,9); printf("3.-MULTIPLICACION");
gotoxy(10,11); printf("4.-DIVISION");
gotoxy(10,13); printf("QUE OPCION DESEA==>");
scanf("%d",&op);
switch(op)
{
Utilizamos la sentencia
case 1:
switch para el menú de
do
opciones.
{
clrscr();
borde();
gotoxy(30,3);printf("1.-SUMA");
gotoxy(11,7); printf("VECTOR 1");
gotoxy(40,7); printf("SUMA VECTOR");
gotoxy(10,5); printf("INGRESE LIMITE==>");
scanf("%d",&limite1);
ingreso(limite1);
suma(limite1);
gotoxy(10,23);
Diseño de la segunda
printf("SI DESEA REPETIR EL
opción del menú de
PROCESO PRESIONE 1 CASO
opciones llamamos a las
CONTRARIO 0==>");
funcione y utilizamos el
scanf("%d",&opc);
ciclo do while pa repetir el
}
while(opc==1);
proceso la veces que
break;
desee el usuario, lo
case 2:
cerramos con un break.
do
{
clrscr();
borde();
gotoxy(30,3); printf("2.-RESTA");

167

gotoxy(40,7); printf("RESTA VECTOR");
ingreso(limite1);
resta(limite1);
gotoxy(10,23); printf("SI DESEA REPETIR
EL PROCESO PRESIONE 1 CASO CONTRARIO 0==>");
Diseño de la tercera
scanf("%d",&opc);
}
while(opc==1);
break;
case 3:
do
{
clrscr();
borde();
gotoxy(30,3); printf("3.-MULTIPLICACION");
gotoxy(40,7); printf("MULTIPLICACION VECTOR");
ingreso(limite1);
multi(limite1);
gotoxy(10,23); printf("SI DESEA REPETIR EL PROCESO PRESIONE 1 CASO CONTRARIO 0==>");
scanf("%d",&opc);
}
while(opc==1);
break;
do
{
case 4:
clrscr();
Diseño de la cuarta
borde();
gotoxy(30,3); printf("4.-DIVISION");
gotoxy(40,7); printf("DIVISION VECTOR");
ingreso(limite1);
division(limite1);
gotoxy(10,23); printf("SI DESEA REPETIR
EL PROCESO PRESIONE 1 CASO CONTRARIO 0==>");
scanf("%d",&opc);
}

168

Cerramos el switch

while(opc==1);
limpiamos pantalla y
break;
volvemos a llamar a la
}
clrscr();
función borde.
borde();
gotoxy(10,23);
printf("SI DESEA VOLVER AL MENU PRESIONE 1 CASO CONTRARIO O==>");
scanf("%d",&op);
Cerramos el ciclo do while
}
escribiendo un mensaje
while(op==1);
getch();
Pausa.
}

Cerramos la función main.


169

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

#include<conio.h>
Activación de librería esto habilita
#include<stdio.h>
procesos para el programa
#include<stdlib.h>
int i, j=1, f, vect[10], vectpar[10], vectimp[10], op, l;
void bdob()
Función borde
{
int i;
clrscr();
gotoxy(1,1);printf("*");
for(i=2;i<=79;i++)
{
Generación del borde
}
utilizando posiciones e
imprimiendo el borde que
va a ir en pantalla
for(i=2;i<=23;i++)
{
}
}
void par()
{
j=1;
for(i=1;i<=l;i++)
{
Proceso de comparación si la
if(i%2==0)
posición es par y se
{
almacenara en un nuevo
vectpar[j]=vect[i];
vector y se imprimirá en
j=j+1;
}
pantalla utilizaremos el
}
gotoxy para posiciones en
f=10;
pantalla
for(i=1;i<j;i++)
{
gotoxy(39,f);printf("%d",vectpar[i]);
f=f+1;
}
}

172

Función para ver si la posición es impar
void impar()
{
j=1;
for(i=1;i<=l;i++)
Comparación si la función es impar
{
if(i%2==1)
{
vectimp[j]=vect[i];
Almacenamiento en un nuevo
j=j+1;
vector
}
}
f=10;
for(i=1;i<j;i++)
{
Impresión de datos de las
gotoxy(60,f);printf("%d",vectimp[i]);
posiciones impares
f=f+1;
}
}
void main()
Programa principal
{
do
Do while este nos ayuda a utilizar el programa
{
cuantas veces deseemos
flushall();
f=10;
Limpia pantalla
clrscr();
bdob();
Llama a la función del borde
gotoxy(36,3);printf("VECTORES");
gotoxy(5,5);printf("Ingrese el limite>> ");scanf("%d",&l);
Pide ingresar un limite de
gotoxy(15,8);printf("VECTOR 1");
generación de datos
gotoxy(29,8);printf("POSICIONES IMPAR");
gotoxy(51,8);printf("POSICIONES PAR");
for(i=1;i<=l;i++)
{
gotoxy(3,f);printf("INGRESO %d::",i);
Ingreso de datos del vector
do
{
gotoxy(20,f);printf(" ");
Validación de los datos, estos
gotoxy(20,f);scanf("%d",&vect[i]);
deben ser mayor que seis y
}
menor que veinte y seis
while(vect[i]<6 || vect[i]>26);
f=f+1;
}
Llama a la función par
par();
Llama a la función impar
impar();
gotoxy(3,22);printf("PRESIONE 1 PARA CONTINUAR O 0CASO CONTRARIO::> ");scanf("%d",&op);
}
while(op==1);
Cierre del do while

173

getch();
}

Cierre o fin del programa

ANALISIS:
Nos pedirá ingresar un límite de datos y al frente nos debe imprimir en un vector los datos de las
posiciones pares y en otro vector nos imprimirá los datos de las posiciones impares. Como así
también nos genera un borde como diseño del programa, y como final tenemos ingresar uno para
continuar utilizando nuestro programa o 0 para salir del mismo.


42.- Diseñe un programa utilizando funciones y vectores que me permita generar un vector de
posiciones pares con la serie del fibonasi y las posiciones impares con el factorial.

posiciones pares con la serie de Fibonacci, y las posiciones impares con el factorial.
#include<stdio.h>
#include<conio.h>

nuestro programa

174

int a,b,c,lim,vect[15],fi,i,f,aux;
void borde()
{
for (i=1;i<=80;i++)
{
Nuestro borde
}
for (i=1;i<=24;i++)
{
}
}
void fibo()
{
después
a=1;
b=0;
for(i=1;i<=lim;i++)
{
c=a+b;
a=b;
b=c;
Sentencia for, procesos y sus
vect[i]=c;
}
respectivos resultados en su primer
fi=9;
programa de Fibonacci
for(i=1;i<=lim;i++)
{
gotoxy(30,fi);printf("%d",vect[i]);
fi=fi+2;
}
}
void factorial()
después
{
f=1;
for(i=1;i<=lim;i++)
{
f=f*i;
vect[i]=f;
}
respectivos resultados en su segundo
fi=8;
programa de Factorial de un numero
for(i=1;i<=lim;i++)
{
gotoxy(30,fi);printf("%d",vect[i]);
fi=fi+2;
}
Comenzaremos con el
}
programa principal
void main ()

175

{
do
{
clrscr();
borde();
gotoxy(23,6);printf("vectores fibonacci y factorial ");
Ingreso del limite y su titulo
gotoxy(5,8);printf("limite: ");scanf("%d",&lim);
fibo();
Llamamos a las funciones
factorial();
gotoxy(18,23);printf("DESEA REALIZAR OTRA REPETICION 1/0: ");
scanf("%d",&aux);
while
}while(aux==1);
getch();
Pausado en el programa y
}
cerrado del programa

ANALISIS:











Primero empezamos abriendo nuestras bibliotecas
Después validamos nuestras variables globales, que servirán para la ejecución
de nuestro programa
Realizamos nuestra primera función llamada borde que nos servirá para más
después abrir en nuestras funciones realizadas
Comenzamos a realizar nuestra primera función llamada fibo, en esta se
guardaran todos los procesos para poder hacer nuestro primera programa
llamado Fibonacci, tomando en cuenta que estamos realizando nuestras
impresiones con vectores.
Después de esto comenzaremos otra función llamado factorial, en la cual
haremos todos los procesos respectivos a nuestro segundo programa para
encontrar el factorial de un número, así mismo con sus respectivas
impresiones con vectores
Por ultimo realizaremos nuestro programa principal en el cual solo
visualizaremos un límite y continuamente llamar a nuestras anteriores
funciones en las cuales se han guardado todos los procesos de cada
programa, llamaremos a nuestro borde i limpiado de pantalla
Por ultimo haremos que se repita nuestro programa con una sentencia do
while y cerraremos nuestro programa.

176


177


43.- Diseñe un programa con funciones y vectores que me permita ingresar n elementos en un
vector entre 3 y 23, recorre el vector encontrar todos las datos pares y asignarlos a un nuevo
vector, encontrar todos los datos impares y asignarlos a un vector, visualice tanto el vector de
entrada como resultado.


178

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int i,fila,lim,j,vector[15],h,vectpar[15],vectimpar[15],col,aux;
nuestro programa
void borde()
{
for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)
Nuestro borde
{
}
}
void ingreso()
después
{
fila=10;
col=10;
for(i=1;i<=lim;i++)
{
do
{
gotoxy(col,fila);printf(" ");
Cerramos la Validación de nuestro vector
gotoxy(col,fila);scanf("%d",&vector[i]);
}while (vector[i]<3||vector[i]>23);
con la sentencia while entre 3 y 23
fila=fila+1;
}
}
void impar()
{
j=1;
for(i=1;i<=lim;i++)
Sentencia for, sentencia if con el cual
{
identificaremos a las números
if(vector[i]%2==1)
impares
{
vectimpar[j]=vector[i];
j=j+1;
}
}
}
void par()
{
h=1;

179

for(i=1;i<=lim;i++)
{
if(vector[i]%2==0)
{
vectpar[h]=vector[i];
h=h+1;
}
}

Sentencia for, sentencia if con el cual
identificaremos a las números pares

}
void impresion()
{
fila=10;
col=20;
for(i=1;i<j;i++)
{
gotoxy(col,fila);printf("%d",vectimpar[i]);
fila=fila+1;
}
}
void impre()
{
fila=10;
col=30;
for(i=1;i<h;i++)
{
gotoxy(col,fila);printf("%d",vectpar[i]);

Sentencia for, i la impresión de
nuestro primer resultado vector
resultante impar

Sentencia for, i la impresión de
nuestro primer resultado vector
resultante impar

fila=fila+1;
}
}
main()
{
do
{
clrscr();
Llamamos a nuestra primera función
borde();
borde
gotoxy(24,6);printf("ing rese el limite==> ");scanf("%d",&lim);
gotoxy(8,8);printf("vector");
gotoxy(20,8);printf("impares");
gotoxy(30,8),printf("pares") ;
borde();
ingreso();
Llamamos a todas nuestras
par();
funciones que anteriormente las
impar();

Impresión del limite

hicimos

180

impresion();
impre();
gotoxy(18,22);printf("DESEA REALIZAR UNA REPETICION 1/0:
");scanf("%d",&aux);
}
while(aux==1);
getch();
}


ANALISIS:










Primero comenzamos abriendo nuestras librerías
Validamos nuestras variables globales, las cuales ocuparemos en nuestro programa
Empezamos con nuestra primera función llamada borde
Seguidamente abrimos otra función la cual será el ingreso de las variables y dentro de
esta imprimiremos el vector con un do while validándolo entre 3 y 23
Continuamente realizamos otra función la cual se llamara impar, en esta realizaremos
procesos y la sentencia para reconocer si es impar
Así mismo realizamos otras función llamada par, en esta realizaremos procesos y la
sentencia if para reconocer si es par
Realizamos otra función llamado ingreso en el cual imprimimos el resultado impar
Continuamos otra función llamado ingr en el cual imprimimos el resultado par
Ahora realizaremos otro void main en el cual ira nuestro programa principal, ingresando
un límite y posteriormente llamaremos a todas las funciones, y cerraremos nuestra
sentencia do while, y al finalizar cerramos con el getche y nuestro programa.


181


44,.Diseñe un programa en c utilizando vectores y funciones que me permita generar con
cualquier factor impar ingresado desde teclado las posiciones pares del vector, y con um factor
par las posiciones impares del vector.

#include<stdio.h>
Librerías
#include<conio.h>
int j,fila,vecfi[10],i,f1,f2,limite,facpar,facimp,op;
void borde()
{
for(i=1;i<=24;i++)
{
Función global para el borde,
gotoxy(2,i);printf("-");
e inicio del ciclo, da color
}
for(i=1;i<=80;i++)

184

{
gotoxy(i,2);printf("-");
}
}
void factor()
{
fila=10;
Inicio de la función factor y
int limitetab;
del ciclo for
limitetab=0;
for (j=1;j<=limite;j++)
{
if(j%2!=0)
{
limitetab=limitetab+1;
vecfi[i]=facpar*limitetab;
gotoxy(10,fila);printf("%d",vecfi[i]);
fila=fila+1;
Condición para calcular los
}
factores impares y pares
else
{
vecfi[i]=facimp*limitetab;
gotoxy(10,fila);printf("%d",vecfi[i]);
fila=fila+1;
}
}
}
Inicio del programa
void main()
principal
{
do
{
clrscr();
Inicio de el ciclo do while
borde();
llamamos al borde ye
gotoxy(8,4);printf("Ingrese el limite: "); scanf("%d",&limite);
ingresamos el limite
do
{
Ingreso de los
gotoxy(5,6);printf("par:");scanf("%d",&facpar);
números pares
}
while(facpar%2==1);
do
{
gotoxy(5,7);printf("impar: ");scanf("%d",&facimp);
}
Ingreso de los impares,
while(facimp%2==0);
repetición del proceso y fin
factor();
del programa
gotoxy(3,22); printf("nuevo proceso 1 salir 0: "); scanf("%d",&op);

185

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

ANALISIS:











de nuestro programa
Comenzamos a realizar nuestra primera función llamada serie, en esta se
llamado asignación de un factor , tomando en cuenta que estamos realizando
nuestras impresiones con vectores.
Después de esto comenzaremos otra función llamado ascenderte y
descendente, en la cual haremos todos los procesos respectivos a nuestro
segundo programa para ordenar nuestra combinación de números, así mismo
con sus respectivas impresiones con vectores


186

45.-Diseñe un programa utlizando vectores y funciones que me permita ordenar un vector en
forma ascendente y descendente. Ingresado entre 6 y 26.

#include<stdio.h>
Librerías, declaración de
#include<conio.h>
variables he inicio de la
#include<stdlib.h>
función borde
int i,conta,residuo,j,op,fila=5,k,aux,limite,vec[10];
void borde()
{
for(i=1;i<=79;i++)
{
Proceso de borde
}
for(i=1;i<=23;i++)
{
}
}
Inicio de la función para el
void ingreso()
ingreso con un rango entre
{
int fila=5;
6 y 26

187

{
do
{
gotoxy(5,fila);printf(" ");
gotoxy(5,fila);scanf("%d",&vec[i]);
}
while((vec[i]<6)||(vec[i]>26));
fila=fila+1;
}
}
void ascendente ()
{
int fila=5;
for (i=1;i<=limite;i++)
{
{
if (vec[i]<vec[j])
{
aux=vec[i];
vec[i]=vec[j];
vec[j]=aux;
}
}
}
{
gotoxy(40,fila);printf("%d",vec[i]);
fila=fila+1;
}
}
void descendente ()
{
int fila=5;
{
{
if (vec[i]>vec[j])
{
aux=vec[i];
vec[i]=vec[j];
vec[j]=aux;
}
}
}

Inicio de función
ascendente calculamos
con dos for y una
condición Y para la
impresión un for mas para
el vector

Inicio de función
descendente calculamos
con dos for

Usamos una
condición Y para
la impresión un
for mas para el
vector

188

{
fila=fila+1;
}
}
void main()
{
do
{
clrscr();
borde();
gotoxy(3,2);printf("ingrese el limite....: ");scanf("%d",&limite);
gotoxy(2,4);printf("INGRESO");
gotoxy(30,4);printf(" ASCENDENTE DESCENDENTE");
ingreso();
ascendente();
descendente();
gotoxy(3,22);printf("pulse 1 para volver y salir 0.....: ");scanf("%d",&op);
}
while (op==1);
getch();
}

Inicio del
programa
principal
llamamos
funciones he
ingresamos el
limite

ANALISIS:









de nuestro programa
Comenzamos a realizar nuestra primera función llamada primo, en esta se
llamado números primos, tomando en cuenta que estamos realizando
Después de esto comenzaremos otra función llamado orden, en la cual
haremos todos los procesos respectivos a nuestro segundo programa ordenar
nuestros números primos en forma ascendente y descendente, así mismo con
sus respectivas impresiones con vectores

189





46.-Diseñe un programa utilizando vectores y funciones que me permita generar un
vector de n elementos con un factor ingresado desde teclado en las posiciones impares
del vector y factorial en las posiciones pares del vector presente en el vector ordenado
en forma ascendente y descendente.
#include<conio.h>
#include<stdio.h>
int i, f, fact, factor, aux, aux1, vectser[10], lim, op, factor1, j;
void borde()
{
clrscr();
for (i=1;i<=80;i++)
{
Nuestro borde

nuestro programa

190

}
for (i=1;i<=24;i++)
{
}
}
void serie(int l)
después
{
gotoxy(40,5);printf("Factor: ");scanf("%d",&factor);
factor1=0;
fact=1;
aux=1;
Sentencia for e if, procesos y sus
f=11;
for(i=1;i<=l;i++)
{
sección del programa
if(i%2==1)
{
factor1=factor1+factor;
vectser[i]=factor1;
}
respectivos resultados en su primera
else
{
fact=fact*aux;
aux=aux+1;
vectser[i]=fact;
}
gotoxy(7,9);printf("COMBINACION DE SERIES");
gotoxy(16,f);printf("%d",vectser[i]);
f=f+1;
}
}
void orden(int l)
{
después
for(i=1;i<=l;i++)
{
for(j=1;j<=l;j++)
{
Sentencia for , procesos y sus
if(vectser[i]<vectser[j])
{
respectivos resultados en la siguiente
aux1=vectser[i];
vectser[i]=vectser[j];
vectser[j]=aux1;
}
}
}

191

gotoxy(35,9);printf("::ASCENDENTE");
f=11;
for(i=1;i<=l;i++)
{
f=f+1;
}

for(i=1;i<=l;i++)
respectivos resultados en la siguiente
{
sección del programa ordenando en
for(j=1;j<=l;j++)
forma ascendente
{
if(vectser[i]>vectser[j])
{
aux1=vectser[i];
vectser[j]=aux1;
}
}
}
Sentencia for y la continuación de la
gotoxy(54,9);printf("::DESCENDENTE");
anterior sección del programa ahora
f=11;
for(i=1;i<=l;i++)
ordenando en forma descendente
{
f=f+1;
}
Comenzaremos con el
}
programa principal
void main()
{
do
{
clrscr();
borde();
Ingreso del limite y su titulo
gotoxy(5,5);printf("Ingrese el limite:");scanf("%d",&lim);
serie(lim);
orden(lim);
Cerramos la
gotoxy(3,22);printf("Presione 1 para volver a repetir o 0 para finalizar");
sentencia do while
scanf("%d",&op);
}
while(op==1);
getch();
}
ANALISIS:
192












de nuestro programa
Comenzamos a realizar nuestra primera función llamada serie, en esta se
llamado asignación de un factor , tomando en cuenta que estamos realizando
Después de esto comenzaremos otra función llamado ascenderte y
descendente, en la cual haremos todos los procesos respectivos a nuestro
segundo programa para ordenar nuestra combinación de números, así mismo
con sus respectivas impresiones con vectores


193


47.- Diseñe un programa utilizando vectores y funciones que me permita ingresar n
elementos en un vector entre 3 y 25 recorra el vector y encuentre todos aquellos
valores que sean números primos asígnelos a un nuevo vector y presente a un vector
resultante en forma ascendente y descendente.

195

#include<conio.h>
#include<stdio.h>
int f1, aux, num, i, j, f, vect[100], vectser[100], lim, op, cont;
nuestro programa
void borde()
{
for(i=1;i<=80;i++)
{
Nuestro borde
}
for(i=1;i<=24;i++)
{
}
}
void primo(int l)
{
después
f=9;
f1=9;
for(j=1;j<=l;j++)
{
Abrimos el do para validar un valor
do
{
gotoxy(18,f);printf(" ");
Cerramos el proceso de
gotoxy(18,f);scanf("%d",&vect[j]);
validación
}
while(vect[j]<3 || vect[j]>25);
f=f+1;
cont=0;
for(i=1;i<=vect[j];i++)
{
if(vect[j]%i==0)
{
cont=cont+1;
}}
if(cont==2)
{
programa de el de encontrar los
vectser[j]=vect[j];
numeros primos
gotoxy(34,f1);printf("%d",vectser[j]);
f1=f1+1;
}
}}
void orden(int l)

196

{
for(i=1;i<=l;i++)
{
for(j=1;j<=l;j++)
{
if(vectser[i]<vectser[j])
{
aux=vectser[i];
vectser[j]=aux;
}
}
}
gotoxy(42,7);printf("ASCENDENTE");
f=9;
for(i=1;i<=l;i++)
{
f=f+1;
}
for(i=1;i<=l;i++)
{
for(j=1;j<=l;j++)
{
if(vectser[i]>vectser[j])
{
aux=vectser[i];
vectser[j]=aux;
}
}
}
gotoxy(58,7);printf("DESCENDENTE");
f=9;
for(i=1;i<=l;i++)
{
f=f+1;
}
}

respectivos resultados en su segundo
programa ordenando su vector en
forma ascendente y forma
descendente

Comenzaremos con el
programa principal

void main()
{
do
{
clrscr();

197

borde();
Ingreso del
gotoxy(21,3);printf("<<numeros primos en forma ascendete y descendente>>");
límite y su
gotoxy(5,5);printf("Ingrese el limite>> ");scanf("%d",&lim);
titulo
gotoxy(13,7);printf("VECTOR");
gotoxy(30,7);printf("# primos");
primo(lim);
orden(lim);
gotoxy(3,22);printf("Presione 1 para volver a ingresar otro dato o 0 para
Cerramos la
finalizar");scanf("%d",&op);
sentencia do while
}
while(op==1);
getch();
}

ANALISIS:











de nuestro programa
Comenzamos a realizar nuestra primera función llamada primo, en esta se
llamado números primos, tomando en cuenta que estamos realizando
Después de esto comenzaremos otra función llamado orden, en la cual
haremos todos los procesos respectivos a nuestro segundo programa ordenar
nuestros números primos en forma ascendente y descendente, así mismo con
sus respectivas impresiones con vectores


198


49.- Diseñe un programa en c++ utilizando funciones que me permita leer una cadena de
caracteres, ingresar desde teclado un caracter que desee buscar en la cadena ingresada, asignela
a un nuevo vector e imprimalo en un vector resultante.

#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<ctype.h>
char nombre[20],a;
int i,fi,n,op, cont;
void borde()
{
for(i=1;i<=79;i++)
{
textcolor(17);


Iniciamos los valores de nuestro programa

Nuestro borde

201

}
for(i=2;i<=23;i++)
{
textcolor(17);
}
}

void nomb()
después
{
flushall();
Permite leer el carácter
gotoxy(12,5);gets(nombre);
n=strlen(nombre);
Permite almacenar en otro vector
fi=5;
for(i=0;i<n;i++)
{
if(islower (nombre[i]))
{
For para ingresar el vector,
nombre[i]=toupper(nombre[i]);
utilizamos la función textcolor para
textcolor(i+1);
poner color a las letras
gotoxy(40,fi);cprintf("%c",nombre[i]);
fi=fi+1;
}
if(nombre[i]==a)
{
cont=cont+1;
textcolor (3);
gotoxy(30,10);cprintf("Letras>> %d",cont);
}}
Comenzaremos con el
}
programa principal
void main()
{
do
{
clrscr();
borde();
nomb();
textcolor(2);
Imprimir el título y subtítulos
gotoxy(12,18);cprintf("ingrese el caracter ");scanf("%c",&a);
de nuestro programa
textcolor(3);
for(i=0;i<n;i++)
{
if(nombre[i]==a)
For para su limite y el if para buscar
{
su posición par

202

cont=cont+1;
}}
textcolor (3);
gotoxy(15,15);cprintf("Letras>> %d",cont);
gotoxy(12,22);cprintf("desea repetir 1 salir 0: ");scanf("%d",&op);
}while(op==1);
getch();
}

Cerramos la
sentencia do while

ANALISIS:












Después validamos nuestras variables globales, que servirán para la
ejecución de nuestro programa, teniendo en cuenta que estamos
ocupando char que servirá para hacer cadena de caracteres.
Realizamos nuestra primera función llamada borde que nos servirá para
más después abrir en nuestras funciones realizadas
Comenzamos a realizar nuestra primera función llamada nomb, en esta
se guardaran todos los procesos para poder hacer nuestro primer
programa donde está el ingreso y las etiquetas de nuestro programa,
además ingresaremos el carácter y un proceso de for en el cual se
almacenen un vector con sus respectivos caracteres.
Después de esto comenzaremos otra función llamado impar, en la cual
haremos todos los procesos respectivos a nuestro segundo programa el
cual ira comparando las posiciones impares de nuestro vector anterior y
ahora irlo almacenando en un vector nuevo.
llamaremos a nuestras anteriores funciones en las cuales se han
guardado todos los procesos de cada programa, llamaremos a nuestro
borde i limpiado de pantalla
Por ultimo haremos que se repita nuestro programa con una sentencia
do while y cerraremos nuestro programa.


203

50.- Diseñe un programa utilizando funciones y vectores que me permita leer una
cadena de caracteres, leer el vector y encontrar todos los datos que se encuentren en
posición de impares del vector y asignarlos a un nuevo vector, presente el nuevo vector
ordenado.
#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<ctype.h>
char nombre[20],vecimpar[20];
int i,fi,op,n,h;
void borde()
{
for(i=1;i<=79;i++)
{
textcolor(9);

Librerías.- colección de clases y funciones,
escritas en el núcleo del lenguaje.
Variables.- son un tipo de
datos, Alfabéticas y enteras.

206

}
for(i=2;i<=23;i++)
{
textcolor(9);
}
}
void nomb()
{
flushall();
textcolor(3);
gotoxy(5,5);cprintf("TEXTO:");
textcolor(i+1);
n=strlen(nombre);
fi=9;
for(i=0;i<n;i++)
{
textcolor(3);
gotoxy(5,7);cprintf("VECTOR");
textcolor(i+1);
fi=fi+1;
}
}
void impar()
{
h=1;
for(i=0;i<n;i++)
{
if(i%2==0)
{
vecimpar[h]=nombre[i];
h=h+1;
}
}
fi=8;
for(i=0;i<h;i++)
{
textcolor(3);
gotoxy(15,7);cprintf("POSICIONES");
textcolor(i+1);

Sentencia “for” para
realizar el borde

Funciones.- Las funciones son bloques de código utilizados
para dividir un programa en partes más pequeñas

Color para el texto
Lectura de variables

Un vector, también llamado array(arreglo)
unidimensional, es una estructura de datos que
permite agrupar elementos del mismo tipo y
almacenarlos en un solo bloque de memoria juntos,
uno después de otro.

Sentencia “for” para la impresión de las letras
en posiciones impares.

207

gotoxy(20,fi);cprintf("%c",vecimpar[i]);
fi=fi+1;
}
}
Inicio del programa
void main()
Sentencia do while
{
do
Borrar pantalla
{
Función borde
clrscr();
borde();
textcolor(2);
gotoxy(15,3);cprintf("VECTORES");
nomb();
Funciones
impar();
gotoxy(5,22);cprintf("Desea repetir 1 Salir 0: ");scanf("%d",&op);
}while(op==1);
Pausa
getch();
Fin del programa
}
pantalla
ANÁLISIS
Empezamos abriendo las librerías para activar funciones, utilizamos variables de tipo
enteras y alfabéticas tres funciones con sentencia “for”, una para el borde y las dos
restantes para realizar los procesos y al impresión de las letras qu están en las
posiciones impares, un do-while para repetir los procesos cuantas veces se desee,
empezamos el programa con viod main, llamamos a las funciones, e imprimimos
resultados.


208

51.- Diseñe un programa utilizando funciones y vectores que me permita leer una cadena
de caracteres y recorrer dicha cadena y encontrar solo aquellas que sean consonantes,
agruparlas y colocarlas en un nuevo vector.
#include<stdio.h>
#include<string.h>
#include<ctype.h>
#include<conio.h>
char tex[20],tex1[20];
int i,n,fi,h,op;
void borde()
{
for(i=1;i<=79;i++)
{
textcolor(6);
}
for(i=2;i<=23;i++)
{
textcolor(6);
}
}
void conso()
{
flushall();
fi=9;
textcolor(5);
gotoxy(5,5);cprintf("TEXTO: ");
gets(tex);
gotoxy(5,8);cprintf("VECTOR");
n=strlen(tex);

Librerías.- colección de clases y funciones,
escritas en el núcleo del lenguaje.
Variables.- son un tipo de
datos, Alfabéticas y enteras.

Sentencia “for” para
realizar el borde

Funciones.- Las funciones son bloques de código utilizados
para dividir un programa en partes más pequeñas

for(i=0;i<n;i++)
{
textcolor(5);
gotoxy(20,8);cprintf("CONSONANTES");
textcolor(i+1);
gotoxy(8,fi);cprintf("%c",tex[i]);
fi=fi+1;
}

Color para el texto
Lectura de variables

Un vector, también llamado array(arreglo)
unidimensional, es una estructura de datos que
permite agrupar elementos del mismo tipo y
almacenarlos en un solo bloque de memoria
juntos, uno después de otro.

211

fi=9;
for(i=0;i<n;i++)
{
if(tex[i]!='a' && tex[i]!='e' && tex[i]!='i'
&& tex[i]!='o' && tex[i]!='u' )
Sentencia “for” para la impresión de las letras
{
en posiciones impares.
tex1[h]=tex[i];
textcolor(i+1);
gotoxy(25,fi);cprintf("%c",tex1[h]);
h=h+1;
fi=fi+1;
}
}
}
void main()
Inicio del programa
{
do
Sentencia do while
{
clrscr();
Borrar pantalla
borde();
Función borde
textcolor(5);
gotoxy(25,3);cprintf("VECTORES");
Funciones
conso();
gotoxy(5,22);printf("Repetir el proceso 1 salir 0: ");scanf("%d",&op);
}while(op==1);
Pausa
getch();
Fin del programa
}
pantalla
ANALISIS:
Empezamos abriendo las librerías para activar funciones, utilizamos variables de tipo
enteras y alfabéticas tres funciones con sentencia “for”, una para el borde y las dos
restantes para realizar los procesos y al impresión de las consonantes, un do-while
para repetir los procesos cuantas veces se desee, empezamos el programa con viod
main, llamamos a las funciones, e imprimimos resultados.


212

52.-Diseñe un programa con funciones y vectores que me permita leer caracteres y visualizar en
un vector resultante en forma invertida.
#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<ctype.h>
char nombre[20],vecimpar[20];
nuestro programa
int i,fi,op,n,h,j,aux,col;
void borde()
{
for (i=1;i<=80;i++)
{
}
Nuestro borde
for (i=1;i<=24;i++)
{
}
}
void nomb()
después
{
flushall();
gotoxy(25,3);printf("VECTORES CON CARACTERES INVERTIDOS");
gotoxy(10,5);printf("ingrese caracter:");
gotoxy(19,7);printf("vector ordenado:");
gotoxy(40,7);printf("vector invertido:");

de nuestro programa

n=strlen(nombre);
fi=9;
for(i=0;i<n;i++)
{
textcolor(i+1);
fi=fi+1;
}
For para ingresar el vector, utilizamos la
fi=7;
función textcolor para poner color a las letras,
fi=fi+1;
for(i=n;i>=0;i--)
además lo estamos invirtiendo para imprimir
{
en un nuevo vector
textcolor(i+1);
fi=fi+1;
}
}
Comenzaremos con el
void main()
programa principal
{
do

215

{
clrscr();
borde();
nomb();

Llamamos a la función

gotoxy(12,22);printf("desea repetir 1 salir 0: ");scanf("%d",&op);
}while(op==1);
getch();
}

while

ANALISIS:










Después validamos nuestras variables globales, que servirán para la ejecución de
nuestro programa, teniendo en cuenta que estamos ocupando char que servirá para
hacer cadena de caracteres.
Realizamos nuestra primera función llamada borde que nos servirá para más después
abrir en nuestras funciones realizadas
Comenzamos a realizar nuestra primera función llamada nomb, en esta se guardaran
todos los procesos para poder hacer nuestro primer programa donde está el ingreso y las
etiquetas de nuestro programa, además ingresaremos el carácter y un proceso de for en
el cual se almacenen un vector con sus respectivos caracteres en forma invertida.
Por ultimo realizaremos nuestro programa principal en el cual solo llamaremos a
nuestras anteriores funciones en las cuales se han guardado todos los procesos de cada
Por ultimo haremos que se repita nuestro programa con una sentencia do while y
cerraremos nuestro programa.


216

53.- Diseñe un programa utilizando funciones y vectores que se permita leer una cadena de
caracteres y recorrer dicha cadena y encontrar solo aquellos que sean consonantes, agruparlos y
colocarlos en un nuevo vector

#include<stdio.h>
#include<string.h>
#include<ctype.h>
#include<conio.h>
char tex[20],tex1[20],op;
nuestro programa
int i,n,fi,h;
void borde()
{
for (i=1;i<=80;i++)
{
}
Nuestro borde
for (i=1;i<=24;i++)
{
}
}
void pro()
después
{
do
{
fi=9;
textcolor(i+1);
Imprimir el título y
gotoxy(25,3);printf("VECTOR CON CARACTER Y CONSONANTES");
subtítulos de
gotoxy(18,7);printf("vector ordenado>>");
nuestro programa
gotoxy(38,7);printf("vector resultante>>");
gotoxy(10,5);printf("ingrese caracter: ");gets(tex);
n=strlen(tex);
for(i=0;i<n;i++)
{
textcolor(i+1);
gotoxy(25,fi);cprintf("%c",tex[i]);
fi=fi+1;
}
For y un if que nos
fi=9;
proporcione la opción
for(i=0;i<n;i++)
de que si no son
{
vocales serán
if(tex[i]!='a' && tex[i]!='e' && tex[i]!='i' && tex[i]!='o' && tex[i]!='u' )
consonantes
{

218

tex1[h]=tex[i];
gotoxy(44,fi);cprintf("%c",tex1[h]);
h=h+1;
fi=fi+1;
}
}
}
Comenzaremos con el
void main()
programa principal
{
Do
{
clrscr();
borde();
pro();
gotoxy(12,22);printf("desea repetir 1 salir 0: ");scanf("%d",&op);
}while(op==1);
getch();
}

while

ANALISIS:










Después validamos nuestras variables globales, que servirán para la ejecución de
nuestro programa, teniendo en cuenta que estamos ocupando char que servirá para
hacer cadena de caracteres.
Realizamos nuestra primera función llamada borde que nos servirá para más después
abrir en nuestras funciones realizadas
Comenzamos a realizar nuestra primera función llamada pro, en esta se guardaran todos
los procesos para poder hacer nuestro primer programa donde está el ingreso y las
etiquetas de nuestro programa, además ingresaremos el carácter y un proceso de for en
el cual se almacenen un vector con sus respectivos caracteres pero en donde solo
encontraremos las consonates.
Por ultimo realizaremos nuestro programa principal en el cual solo llamaremos a
nuestras anteriores funciones en las cuales se han guardado todos los procesos de cada
Por ultimo haremos que se repita nuestro programa con una sentencia do while y
cerraremos nuestro programa.

219


220

55.-Diseñe un programa utilizando vectores y funciones que me permita Ingresar n elementos
entre 3 y 23 en las posiciones impares del vector y las posiciones pares se generan con cualquier
factor ingresado desde teclado, recorra el vector y encuentre todos aquellos valores que sean
números primos y asignarlos a un nuevo vector, presente el vector resultante ordenado en forma
ascendente y descendente.

ANALISIS FLUJOGRAMICO
Librerías
Declaración de Variables int

Lazo For

Función de ingreso
Ingresos e impresiones

Inicializaciones

Lazo For

#include<stdio.h>
#include<conio.h>
int i,lim,fac,op,vect1[15],f,fila,d,aux,c,a,vec[15],j,lim2;
void borde()
{
for(i=1;i<=80;i++)
{
textcolor(i);
}
for(i=1;i<=24;i++)
{
textcolor(i);
}
}
void ingreso()
{
gotoxy(31,5);printf("PROCESO DE VECTORES");
gotoxy(15,7);printf("Limite>> ");scanf("%d",&lim);
gotoxy(45,7);printf("Factor>> ");scanf("%d",&fac);
gotoxy(13,10);printf("Entrada");
f=0;
fila=11;
for(i=1;i<=lim;i++)
{
if(i%2==0)
{
do
{
gotoxy(15,fila);scanf("%d",&vect1[i]);
}while(vect1[i]<3 || vect1[i]>23);
}
if(i%2==1)
{
f=f+fac;

222

Fin de función
Funciones primos
Inicialización variables

Lazo For

Condición If

Fin función

Función Ascendente

Lazo For

vect1[i]=f;
gotoxy(15,fila);printf("%d",vect1[i]);
}
fila=fila+1;
}
}
void primos()
{
lim2=1;
fila=11;
gotoxy(25,10);printf("#s Primos");
for(i=1;i<=lim;i++)
{
a=0;
for(j=1;j<=vect1[i];j++)
{
if(vect1[i]%j==0)
{
a=a+1;
}
}
if(a==2)
{
vec[lim2]=vect1[i];
gotoxy(26,fila);printf("%d",vec[lim2]);
fila=fila+1;
lim2=lim2+1;
}}}

void ascendente()
{
for(i=1;i<lim2;i++)
{
for(j=1;j<lim2;j++)
{
if(vec[i]<vec[j])
{
aux=vec[i];
vec[i]=vec[j];
vec[j]=aux;
}
}
}
fila=11;
for(i=1;i<lim2;i++)

223

Fin de función
Función descendente

Lazo for

Fin de función

Función principal

Llamado de funciones

Lazo Do While
Fin de función

{
gotoxy(38,10);printf("Ascendente");
fila=fila+1;
}
}//cierre
void descendente()
{
for(i=1;i<lim2;i++)
{
for(j=1;j<lim2;j++)
{
if(vec[i]>vec[j])
{
aux=vec[i];
vec[i]=vec[j];
vec[j]=aux;
}
}
}
fila=11;
for(i=1;i<lim2;i++)
{
gotoxy(58,10);printf("Descendente");
fila=fila+1;
}
}//cierre

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

224

ANALISIS:












Codificamos el borde dentro de una funciones
Dentro de otra funciones ingresamos un límite y un factor
Si la posiciones es par debemos condicionar el valor ingresado entre 3 y 23
Si la posiciones es impar realizamos el proceso para que se genere el factor
Realizamos otra función para imprimir los números que sean únicamente primos
Utilizamos un for para verificar si los datos son primos, de ser así se asignara dicho
valor a un vector
Utilizamos otra función para ordenar de forma ascendente los valores asignados al
vector de números primos
De igual manera utilizamos una función para ordenar de forma descendente los
valores asignados al vector de los números primos.
Abrimos la función del programa principal
Llamamos las funciones previamente codificadas


225

56.- Diseñe un programa utilizando funciones y matrices que me permita visualizar los datos en
una matriz y otra matriz resultante con los datos ingresados.

#include<stdio.h>
Librerías
#include<conio.h>
int j,i,k,op,matriz1[10][10],col=10,fila=8,limite,datos,sali,f;
void borde()
{
for(k=2;k<=80;k++)
{
Función para el diseño del borde
gotoxy(k,2);printf("-");
gotoxy(k,24);printf("-");
}
for(k=2;k<=24;k++)
{
gotoxy(2,k);printf("-");
gotoxy(80,k);printf("-");
}
}


226

void ing(int datos)
{
col=10;
fila=8;
{
for(j=1;j<=limite;j++)
{
gotoxy(col,fila); scanf("%d",&matriz1[i][j]);
col=col+5;
}
col=10;
fila=fila+1;
}
}

Función para el ingreso de los
datos de la matriz utilizando ciclos
FOR

void sal(int sali)
{
fila=8;
col=40;
for(i=1;i<=limite; i++)
Función para la impresión de
{
nuestra matriz utilizando ciclos
{
FOR
gotoxy(col,fila); printf("%d",matriz1[i][j]);
col=col+5;
}
col=40;
fila=fila+1;
}
}
Cuerpo principal del programa
void main()
{
do
Ciclo DO-while para repetir n veces
{
clrscr();
Blanqueo de pantalla
borde();

Llamado de la función del

gotoxy(3,3); printf("Ingrese un límite: "); scanf("%d",&limite);
ing(datos);
Llamado de las funciones de la matriz
sal(sali);
gotoxy(4,22); printf("NUEVO 1 SALIR 0: "); scanf("%d",&op);
}
while(op==1);
getch();
Pausar pantalla

Ingreso del límite de
datos
Ciclo DO-while para repetir n
veces

227

ANALISIS:
En este programa utilizaremos funciones tanto para el borde como para ingresar y
presentar los datos de nuestra matriz, esencialmente la utilización de ciclos FOR para
que permita ingresar los datos de nuestra matriz, imprimimos resultados y utilizamos
un DO-WHILE para que el programa se repita n veces quiera el usuario.

57.- Diseñe un programa utilizando funciones y matrices que me permita generar una matriz con
cualquier factor ingresado desde teclado.

#include<stdio.h>
#include<conio.h>
LIBRERIAS
#include<ctype.h>
int i,j,m,matriz[5][5],columna,fila,limite,datos,factor,a,op;
VARIABLES GLOBALES
void borde(int datos)
SE ABRE LA FUNCION DEL BORDE
{
textcolor(YELLOW);
ESCOGER EL COLOR
for(i=1;i<=80;i++)

228

{
}
PROCESO DEL BORDE
for(i=1;i<=24;i++)
{
}
}
SE CIERRA LA FUNCION
void programa(int datos)
FUNCION DEL PROGRAMA
{
SE ABRE LA FUNCION
a=0;
gotoxy(33,3);cprintf("MATRIZ FACTOR");
gotoxy(8,5);cprintf("Limite: ");scanf("%d",&datos);
gotoxy(8,6);cprintf("Factor: ");scanf("%d",&factor);

ENUNCIADOS

columna=10;
fila=10;
for(i=1;i<=datos; i++)
PROCESO DE LA MATRIZ
{
for(j=1;j<=datos; j++)
{
gotoxy(8,8);cprintf("Matriz ingreso");
a=a+factor;
matriz[i][j]=a;
gotoxy(columna,fila);printf("%d",matriz[i][j]);
columna=columna+4;
PROCESO DEL FACTOR
}
columna=10;
fila=fila+2;
}
a=0;
columna=50;
fila=10;
for(i=1;i<=datos; i++)
{
for(j=1;j<=datos; j++)
{
gotoxy(45,8);cprintf("Matriz resultante");
a=a+factor;
matriz[i][j]=a;
PROCESO PARA COPIAR ALADO
EL FACTOR

229

columna=columna+4;
}
columna=50;
fila=fila+2;
}
}
void main ()
SE ABRE LA FUNCION PARA LLAMAR AL PROGRAMA
{
do
{
SE ABRE EL LAZO REPETITIVO
clrscr ();
borde(datos);
programa(datos);
LLAMA A LAS FUNCIONES
gotoxy(3,23);cprintf("DESEA REPETIR PRESIONE 1 O 0 PARA SALIR: ");scanf("%d",&op);
}
SE CIERRA EL LAZO REPETITIVO
while(op==1);
getch();
PARA QUE NO EXISTA ECO
}
SE CIERRA EL PROGRMA
ANALISIS:



Este programa me permite ingresar una matriz de cualquier orden y se imprime los
factores ingresados en toda la matriz.
Ingresamos la librerías y las variables globales abrimos una función para el borde e
ingresamos textcolor(YELLOW); para escoger el color mediente lazos for hacemos
el proceso del borde y cerramos el mismo, abrimos la función del programa
ingresamos en una variable para que se almacene el factor, también se ingresa las
filas y columnas de la matriz, sumamos el factor para la variable ingresada
ubicamos las posiciones de la matriz y cerramos el programa. Abrimos la función
para llamar al proceso ingreso un lazo repetitivo, un limpiador de pantalla,llamo a
la función del borde y del programa cierro el lazo repetitivo ingreso un getch para
que no haiga un eco y por ultimo cierro todo el programa


230

58.- Diseñe un programa utilizando funciones y matrices que me permita Imprimir una
matriz cuadrática de ceros excepto la diagonal principal.
#include<conio.h>
#include<stdio.h>
LIBRERIAS
#include<ctype.h>
int op=1,limite,fila=7,columna=13,i,j;
INGRESAMOS VARIABLES GLOBALES
int matriz[10][10],datos;
void borde()
FUNCION DEL BORDE
{
textcolor(YELLOW);
INGRESAR COLOR
for(i=1;i<=80;i++)
{
}
for(i=1;i<=24;i++)
PROCESO DEL BORDE
{

231

}
}
CIERRO LA FUNCION
void programa(int datos)
FUNCION DEL PROGRAMA
{
ABRIR LA FUNCION
gotoxy(3,5);cprintf("Limite: ");cscanf("%d",&limite);
INGRESAR UN LIMITE
{
ORDENAR LA MATRIZ
{
if(i==j)
{
matriz[i][j]=1;
gotoxy(columna,fila);cprintf("%d",matriz[i][j]);
REALIZA UNA CONDICION
columna=columna+5;
}
else
{
matriz[i][j]=0;
columna=columna+5;
CASO CONTRARIO
}
}
fila=fila+1;
columna=13;
}
}
void main()
FUNCION PARA LLAMAR AL PROGRAMA
{
ABRIR LA FUNCION
do
{
ABRIR UN LAZO REPETITIVO
clrscr();
borde();
SE LLAMA A LA FUNCION BORDE
gotoxy(36,2);cprintf("========");
gotoxy(37,3);cprintf("MATRIZ");
ENUNCIADO
gotoxy(36,4);cprintf("========");
programa (datos);
gotoxy(3,23);cprintf("DESEA REPETIR 1 O 0 PARA SALIR: ");cscanf("%d",&op);
}
while(op==1);
CIERRO LA FUNCION
getch();
}

232

ANALISIS:



Este programa me permite ingresar una matriz de cualquier orden y se imprime de
ceros y su diagonal principal de unos.
Ingresamos las librerías introducimos las variables globales abrimos la función del
borde ingresamos un textcolor(YELLOW); para darle color al diseño mediante lazos
for asemos el margen de la pantalla y cerramos la función abrimos la función del
programa para la matriz visualizamos el límite que se desea ingresar ingresamos
dos lazos for con (i,j) para formar a la matriz, ingresamos una condición si el
número de la fila es igual al de la columna se imprima con unos caso contrario de
ceros cerramos la función. Por ultimo abrimos void main() para llamar al programa
abrimos un lazo repetitivo escribimos un clrscr para limpiar la pantalla llamamos al
borde y al programa y cerramos el programa


59.- Diseñe un programa utilizando matrices y funciones que me permita llenar u a matriz con
valores ceros, a excepción de sus diagonales, en donde la diagonal principal se llena con un
factor cualquiera ingresado desde teclado y la diagonal secundaria con el factorial, visualice la
diagonales principal y secundaria.


233

#include<conio.h>
#include<stdio.h>
Iniciamos los valores de nuestro programa
int op,i,j,fi,c,n,ma[50][50],f,cf,fac;
void borde()
{
for(i=1;i<=79;i++)
{
Nuestro borde
}
for(i=2;i<=23;i++)
{
}
}
void presen(int m)
después
{
c=15;
fi=5;
cf=0;
gotoxy(15,4);printf("Ingrese factor: ");scanf("%d",&f);
de nuestro programa
for(i=1;i<=m;i++)
{
for(j=1;j<=m;j++)
{
if(i==j)
{
cf=cf+f;
ma[i][j]=cf;
gotoxy(c,fi);printf("%d",ma[i][j]);
c=c+3;
}
su posición par
else
{
ma[i][j]=0;
c=c+3;
}
}

234

c=15;
fi=fi+1;
}
}
void diago(int m)
{
después
c=45;
fi=5;
cf=0;
for(i=1;i<=m;i++)
{
for(j=1;j<=m;j++)
{
su posición de la matriz
if(i==j)
{
cf=cf+f;
ma[i][j]=cf;
c=c+3;
}
}
fi=fi+1;
}
}
void diagosec(int m)
{
después
c=45;
fi=5;
fac=1;
for(i=1;i<=n;i++)
{
for(j=m;j>=1;j--)
{
if(i==j)
For para su limite y el if para
{
realizar su factorial
fac=fac*j;
ma[i][j]=fac;
c=c+3;
}
c=c+3;
}
c=45;
fi=fi+1;
}
}
void diagosecu(int m)
después
{

235

c=15;
fi=5;
fac=1;
for(i=1;i<=n;i++)
{
for(j=m;j>=1;j--)
{
if(i==j)
For para su limite y el if para
{
realizar su factorial
fac=fac*j;
ma[i][j]=fac;
c=c+3;
}
c=c+3;
}
c=15;
fi=fi+1;
}
Comenzaremos con el
}
programa principal
void main()
{
do
{
clrscr();
borde();
gotoxy(32,2);printf("INGRESO MATRICES");
gotoxy(15,3);printf("Ingrese el limite: ");scanf("%d",&n);
presen(n);
diago(n);
diagosec(n);
diagosecu(n);
}while(op==1);
while
getch();
}

ANALISIS:
Necesitamos funciones para realizar el ejercicio también necesitamos matrices
necesitamos variables globales para generar un factor cualquiera y otra variable para
generar el factorial.

237

60.-Diseñe un programa utilizando funciones y matrices que me permita Generar una matriz con
la serie del fibonasi, encontrar los datos de sus diagonales visualizarlos en forma de equiz,
asignar estos datos a un vector resultante ordenado en forma ascendente y descendente.


237

#include<conio.h>
Librerías
#include<stdio.h>
int fil, col, aux, i, j, mat[10][10], vect[10], lim, op, a, b, c, h;
void bdob()
{
int i;
clrscr();
for(i=2;i<=79;i++)
{
Función global para el borde
}
for(i=2;i<=23;i++)
{
}
}
void diag()
{
col=5;
Inicio de la función para
fil=8;
a=1;
determinar las diagonales
b=0;
c=0;
for(i=1;i<=lim;i++)
{
for(j=1;j<=lim;j++)
{
Condición para calcular las
c=a+b;
diagonales
a=b;
b=c;
mat[i][j]=c;
gotoxy(col,fil);printf("%d",mat[i][j]);
col=col+4;
Proceso para calcular la
}
serie del fibonasi
col=5;
fil=fil+3;
}
}
void dprinc()
{
col=21;
fil=8;

238

h=1;
for(i=1;i<=lim;i++)
{
for(j=1;j<=lim;j++)
{
if(i==j)
{
vect[h]=mat[i][j];
h=h+1;
col=col+4;
}
}
fil=fil+3;
}
}
Función para calcular la
void dsec()
diagonal secundaria
{
col=28;
fil=8;
j=lim;
for(i=1;i<=lim;i++)
{
vect[h]=mat[i][j];
h=h+1;
j=j-1;
col=col-4;
fil=fil+3;
}
}
void diag_vect()
{
fil=8;
for(i=1;i<h;i++)
{
gotoxy(41,fil);printf("%d",vect[i]);
fil=fil+2;
}
}
void orden()
{
fil=8;
Función para ordenar las
for(i=1;i<h;i++)
{
diagonales.
for(j=1;j<h;j++)
{
if(vect[i]<vect[j])

Inicio de la función calcular la
diagonal principal

Imprimimos la matriz

239

{
aux=vect[i];
vect[i]=vect[j];
vect[j]=aux;
}
}
}
fil=8;
for(i=1;i<h;i++)
{
fil=fil+2;
}
Calculamos el vector
for(i=1;i<h;i++)
descendente
{
for(j=1;j<h;j++)
{
if(vect[i]>vect[j])
{
aux=vect[i];
vect[i]=vect[j];
vect[j]=aux;
}
}
Proceso para ordenar
}
fil=8;
for(i=1;i<h;i++)
{
fil=fil+2;
}
}
Función donde a
void main()
proseguimos a imprimir
{
los datos
do
{
clrscr();
bdob();
gotoxy(34,2);printf("<<MATRICES>>");
gotoxy(5,4);printf("Ingrese el limite>> ");scanf("%d",&lim);
gotoxy(4,6);printf("<<MATRIZ>>");
gotoxy(18,6);printf("<<Diagonales>>");
Pedimos los respectivos
gotoxy(34,6);printf("<<Vector_Diag>>");
datos.
gotoxy(50,6);printf("<<Ascendente>>");
gotoxy(65,6);printf("<<Descendente>>");
diag();
dprinc();
dsec();

240

diag_vect();
orden();
gotoxy(3,22);printf("Presione 1 para volver a repetir el proceso o 0 para finalizar>>
");scanf("%d",&op);
}
while(op==1);
getch();
}

Cerramos la
sentencia do
while


ANALISIS:
Para este programa utilizamos funciones para llamar al procedimiento para
realizar el ejercicio también necesitamos matrices, variables globales para generar
poder realizar los respectivos procedimientos para generar la serie del fibonasi y
asi proseguir a llamar a las distintas funciones en donde se visualice la matriz las
diagonales otra para ordenar ascendentemente y otra para ordenar
descendentemente.

241

BIBLIOGRAFIAS:
http://www.miprimercodigo.com/2011/09/capitulo-vii-matrices/
http://programavideojuegos.blogspot.com/2013/05/25-ejercicios-resueltos-de-arraysy.html#sthash.TFs9x47E.dpuf
http://programavideojuegos.blogspot.com/2013/05/25-ejercicios-resueltos-de-arraysy.html#sthash.TFs9x47E.dpuf
http://www.slideshare.net/ric0608/arreglos-vectores-en-c
http://programavideojuegos.blogspot.com/2013/05/25-ejercicios-resueltos-de-arrays-y.html
http://www.nebrija.es/~abustind/Informatica/MetodologiaI/Elementos_basicos_C.pdf
http://es.scribd.com/doc/67188106/52/SENTENCIAS-COMPUESTAS-O-BLOQUES

242

Programazion

Más contenido relacionado

La actualidad más candente (19)

Similar a Programazion (20)

Más de Diego Rojas (9)

Último (20)

Programazion