c+++

aaaaa

UNIVERSIDAD TÉCNICA DE AMBATO

FACULTAD DE CIENCIA HUMANAS DE LA

EDUACIÓN

DOCENCIA EN INFORMÁTICA

C++ 2

Aaaaa

Ashqui Israel

Contenido

ELEMENTO 1 ............................................................................................................................... 9

TURBO C ++ ................................................................................................................................ 9

TURBO C ++ ........................................................................................................................... 10

Breve historia ........................................................................................................................ 10

CARACTERÍSTICAS DE C++ ..................................................................................................... 10

OPERADORES EN C++............................................................................................................ 11

Tipos de datos en C++ ........................................................................................................... 12

Tipos de datos simples ......................................................................................................... 14

FUNCIONES ........................................................................................................................... 14

La función main() .............................................................................................................. 14

Funciones de E/S básicas .................................................................................................. 15

La función scanf ................................................................................................................ 15

La función printf ................................................................................................................... 15

LIBRERÍAS Y FUNCIONES ....................................................................................................... 16

C++ Cuaderno digital

C++ - Ashqui Israel 3

stdio.h ............................................................................................................................... 16

conio.h............................................................................................................................... 16

getch(); Declaración de variables ........................................................................................ 18

SINTAXIS DE LAS SENTENCIAS Y FUNCIONES DE C ............................................................... 19

SENTENCIA DE ASIGNACION ................................................................................................. 19

ENTRADA Y SALIDA ESTANDAR ............................................................................................. 20

Sentencia if ........................................................................................................................ 20

WHILE:.................................................................................................................................. 21

DO WHILE: ............................................................................................................................ 22

CREACIÓN DE BUCLES ANIDADOS ........................................................................................ 23

SWITCH: ................................................................................................................................ 24

} ............................................................................................................................................. 26

SENTENCIA FOR .................................................................................................................... 26

Contador: .............................................................................................................................. 27

Acumulador: ......................................................................................................................... 28

FUNCIONES C++ .................................................................................................................... 28

Vectores, Matrices y Punteros en c++ ...................................................................................... 29

VECTORES ............................................................................................................................. 29

MATRICES.......................................................................................................................... 31

PUNTEROS ........................................................................................................................ 32

ARITMÉTICA DE PUNTEROS .............................................................................................. 34

VECTORES DINÁMICOS ......................................................................................................... 35

MATRICES Y PUNTEROS .................................................................................................... 36

MATRICES DINÁMICAS ...................................................................................................... 37

ELEMENTO 2 EJERCICIOS C++ ................................................................................................... 39

SENTENCIA IF ........................................................................................................................ 39

Programa N.-1 . - 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. ..................................................................................................................... 39


Análisis: .......................................................................................................................... 40

PROGRAMA N.-2.- Diseñe un programa que me permita ingresar un número

entero desde teclado desde 1 al 7 y que determine o visualice el nombre del día

de la semana que corresponda ....................................................................................... 42

ANALISIS: .......................................................................................................................... 42

PROGRAMA N.-3.- 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 .......................................................................................................... 46

ANALISIS: .......................................................................................................................... 46

CODIFICACION: ............................................................................................................ 46

PROGRAMA N.-4.- Diseñe un programa que me permita ingresar 2 números por

teclado y realizar la suma de los mismos. ................................................................... 49

ANALISIS: .......................................................................................................................... 50

CODIFICACION: ............................................................................................................ 50

PROGRMA N.-5 Realice la suma de 2 números siempre que el primer valor este

entre 3 y 23 y el segundo valor este entre 5 y 17. ...................................................... 51

ANALISIS: .......................................................................................................................... 51

PROGRAMA N.-6. Diseñe un programa que me permita ingresar el nombre de

una persona y la edad de la misma que debe estar entre 3 y 85, para obtener

las siguientes equivalencias: ........................................................................................... 54

ANALISIS: .......................................................................................................................... 54

CODIFICACION: ............................................................................................................ 54

PROGRAMA 7. Diseñe un programa que me permita simular la venta de productos

en una factura, de la cual necesitamos ingresar el nombre del producto, la

cantidad, precio unitario y calcular el precio total. El programa se repite n veces

según los productos que el usuario desee ingresar. ..................................................... 57

ANALISIS: ............................................................................................................................ 57

PROGRAMA N.-9 Diseñe un programa que me permita calcular el promedio

general de las notas de distintas materias correspondientes al 2º Semestre de

Docencia en Informática, en donde cada una de las notas ingresadas debe estar

entre 1 y 10. ........................................................................................................................... 59

Análisis: ........................................................................................................................... 59


PROGRAMA N.-9 Realice un programa en C++ que me permita obtener el líquido a

recibir de un empleado bajo los siguientes parámetros: ............................................. 61

ANALISIS: ............................................................................................................................ 62

CODIFICACION: .............................................................................................................. 62

PROGRAMA N.-10. Diseñe un programa que me permita imprimir un borde de

pantalla. .................................................................................................................................. 66

ANALISIS: ............................................................................................................................ 66

CODIFICADO: .................................................................................................................. 66

PROGRAMA N.-11.- Diseñe un programa que me permita imprimir un borde de

pantalla .................................................................................................................................... 68

Análisis: Este programa nos permite generar un margen o borde en pantalla

para mejorar la presentación en pantalla. .................................................................. 68

Codificación: ................................................................................................................... 69

PROGRAMA N.-12.- Diseñe un programa que me permita visualizar la serie de los

números pares ......................................................................................................................... 70

Análisis: este programa nos va a generar el borde en pantalla así como también

generara los números pares ingresando un límite ingresando desde teclado. .. 70

Corrido: ........................................................................................................................... 70


números pares y los impares que existen hasta el número límite ingresado desde teclado.

.................................................................................................................................................. 72

ANALISIS: este programa nos ayuda a generar números pares e impares y a la

vez nos genera el borde. .................................................................................................. 72

Codificación: ................................................................................................................... 72

PROGRAMA N.-14.- Diseñe un programa que me permita generar las tablas de

multiplicar de cualquier factor ingresado desde teclado y por cualquier limite

ingresado desde teclado, el programa se genera n veces, diseñe el borde en

pantalla. .................................................................................................................................. 74

ANALISIS: este programa genera el borde como también genera la tabla de

multiplicar ingresando por teclado el número y el límite. ...................................... 74

Codificación: ................................................................................................................... 75

Programa 15 .......................................................................................................................... 76

Enunciado: ............................................................................................................................ 76


Codificado ......................................................................................................................... 76

4.-Analisis del Programa: .................................................................................................. 78

Programa 16 ......................................................................................................................... 78

Programa 17 ......................................................................................................................... 80

Programa 18 ......................................................................................................................... 81

Programa 19 ......................................................................................................................... 82

PROGRAMA N.-21. -Diseñe un programa que me permita generar la siguiente

serie de datos: primos en el numerador e impares en el denominador.} ................ 84

CODIFICADO ....................................................................................................................... 84

ANALISIS.......................................................................................................................... 86

PROGRAMA N.-22.-diseñe un programa que me permita generar la siguiente serie

de datos: como numerador los números impares y como denominador la serie

fibonasi. .................................................................................................................................. 86

CODIFICADO: ...................................................................................................................... 86

ANALISIS.......................................................................................................................... 88

PROGRAMA N.-23.- 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. ........................................................................................ 88

CODIFICACION: .................................................................................................................. 88

ANALISIS.......................................................................................................................... 91

PROGRAMA N.24.- Diseñe un programa con un menú de opciones que me

permita calcular las áreas y perímetros de las 4 figuras básicas: circulo, cuadrado,

triangulo, rectángulo. .......................................................................................................... 93

CODIFICACION: .................................................................................................................. 93

} ......................................................................................................................................... 96

ANALISIS.......................................................................................................................... 96

Programa 25 .......................................................................................................................... 98

ANÁLISIS ............................................................................................................................. 98

CODIFICADO: .................................................................................................................. 98

Programa 26 ........................................................................................................................ 101

Analisis: ............................................................................................................................ 102


Codificación: ................................................................................................................. 102

Programa 27 ........................................................................................................................ 105

Análisis : ............................................................................................................................ 105

Codificación: ................................................................................................................. 105

Programa 28 ........................................................................................................................ 108

Codificado: ........................................................................................................................ 109

Programa 29 ........................................................................................................................ 110

Análisis: ............................................................................................................................ 110

Codificación: ................................................................................................................. 110

Programa 30 ........................................................................................................................ 112

Analisis: ............................................................................................................................ 112

CoDIFIcado: .................................................................................................................. 112

Programa 32 ........................................................................................................................ 116

CODIFICADO: ....................................................................................................................... 116

ELEMENTO 3 ........................................................................................................................... 119

ELEMENTO 4 ........................................................................................................................... 120

Funciones vectores matrices .............................................................................................. 120

PROGRAMA 33 ..................................................................................................................... 121

1. ENUNCIADO .................................................................................................................. 121

2. ANALISIS ....................................................................................................................... 121

3. DOCUMENTACION ....................................................................................................... 121

4. CORRIDO DEL PROGRAMA ........................................................................................ 123

PROGRAMA 34 ..................................................................................................................... 124

1. ENUNCIADO .................................................................................................................. 124

2. ANALISIS ....................................................................................................................... 124

3. DOCUMENTACION ....................................................................................................... 124

4. CORRIDO DEL PROGRAMA ........................................................................................ 125

Programa 35 ....................................................................................................................... 126

ENUNCIADO .................................................................................................................... 126

Programa 36 ....................................................................................................................... 130


Programa 37 ....................................................................................................................... 134

Programa 38 ....................................................................................................................... 138

Programa 38 ....................................................................................................................... 141

Programa 39 ....................................................................................................................... 150

Programa 40 ....................................................................................................................... 153

Programa 42 ....................................................................................................................... 156

Programa 43 ....................................................................................................................... 160

Programa 44 ....................................................................................................................... 162

Programa 45 ....................................................................................................................... 166

Programa 46 ....................................................................................................................... 168

Programa 46 ....................................................................................................................... 170

PROGRAMA 48 .................................................................................................................... 175

PROGRAMA 49 .................................................................................................................... 179

Programa 50 ....................................................................................................................... 182

programa51 ........................................................................................................................ 186

Programa 52.- ................................................................................................................... 188

Programa 53 ....................................................................................................................... 191

PROGRAMA 54 .......................................................................................................... 194

Programa 55 ....................................................................................................................... 197

Programa 56 ....................................................................................................................... 198

Programa 57 ....................................................................................................................... 202

Programa 58 ....................................................................................................................... 204

Programa 59 ....................................................................................................................... 207

Programa 60 ....................................................................................................................... 209

Programa 61 ....................................................................................................................... 212

Programa 62 ...................................................................................................................... 218

BIBLIOGRAFIA: ................................................................................................................ 220


ELEMENTO 1

TURBO C ++

C++ comenzó a desarrollarse en 1980 en los laboratorios de la Cía. AT&T. Es una

ampliación del lenguaje C. El nombre C++ proviene del operador incremento ++.

Es un lenguaje potente, versátil y es muy importante para empezar a aprender a

programar. Sus principales características son:

Programación estructurada, Abundancia de operadores y tipos de datos, riqueza y

flexibilidad en las expresiones, sobrecarga de funciones y operadores


TURBO C ++

Breve historia El lenguaje C fue inventado por Dennis Ritchie en 1972 cuando trabajaba, junto con

Ken Thompson, en el diseño del sistema operativo UNIX.

El lenguaje C deriva del lenguaje B de Thompson, el cual, a su vez, deriva del

lenguaje BCPL desarrollado por Martin Richards. Durante muchos años el estándar

de C fue la versión proporcionada con el sistema operativo UNIX versión 5. Pero

pronto empezaron a surgir muchas implementaciones del C a raíz de la popularidad

creciente de los microordenadores. Por este motivo, se hizo necesario definir un C

estándar que está representado hoy por el ANSI C.

En este tutor se va a estudiar el C estándar. No obstante, si la opción turbo está

activada, también se incluirá en la explicación la versión Turbo C de Borland

International, que es uno de los mejores compiladores de C que existen en el

mercado.

Cuando nos referimos a Turbo C, estamos hablando indistintamente de las distintas

versiones que existen sobre los paquetes Turbo C, Turbo C++ y Borland C++,

puesto que en todos ellos se puede programar en C.

El lenguaje C suministrado por Turbo C es, simplemente, una ampliación del ANSI

C, sobre todo en el número de funciones de librería suministradas.

CARACTERÍSTICAS DE C++

El nombre C++ fue propuesto por Rick Mascitti en el año 1983, cuando el

lenguaje fue utilizado por primera vez fuera de un laboratorio científico. Antes

se había usado el nombre "C con clases". En C++, la expresión "C++"

significa "incremento de C" y se refiere a que C++ es una extensión de C.

Programación de bajo nivel (nivel bit).

Lenguaje estructurado.


Lógicos

• Y- AND -&& • O- OR - || • NO- NOT - !

Aritméticos

• Asignación = • Suma + • Resta - • Multiplicación * • División / • División modular% • Incremento ++ • Decremento --

Relacionales

• Igual que == • Menor que < • Mayor que > • Menor o igual

que <= • Mayor o igual

que >= • Diferente que !=

Tiene un conjunto completo de instrucciones de control.

Permite la agrupación de instrucciones.

Tamaño pequeño.

Comandos breves (poco tecleo).

El generar programas eficientes.

Un punto en contra es que tiene una detección pobre de errores, lo cual en

ocasiones es problemático para los principiantes.

La posibilidad de poder ser compilado en una variedad de computadoras, con

pocos cambios (portabilidad).

OPERADORES EN C++

Símbolos que nos ayudarán a relacionar y manipular lo operando,


Tipos de datos en C++ Los tipos de datos primitivos en C++ son: numéricos enteros, numéricos reales, tipo

lógico y tipo carácter ampliado.

Tipos de datos C++ numéricos enteros

El tipo de dato numérico entero es un subconjunto finito de los números enteros del mundo real. Pueden ser positivos o negativos.

En C++ los tipos de datos numéricos enteros son los siguientes:

Tipo de Dato

Descripción Número de bytes típico

Rango

short Entero corto 2 -32768 a 32767

int Entero 4 -2147483648 a +2147483647

long Entero largo 4 -2147483648 a +2147483647

char Carácter 1 -128 a 127

Con los tipos enteros pueden utilizarse los calificadores signed y unsigned. Estos calificadores indican si el número tiene signo o no. Si se usan solos, sin indicar el tipo de dato se asume int. Por ejemplo, las siguientes declaraciones son equivalentes: unsigned int x; equivale a: unsigned x; Usando estos calificadores podemos tener los siguientes tipos enteros:

Tipo de Dato Descripción Número de bytes típico

Rango

signed short Entero corto 2 -32768 a 32767

unsigned short

Entero corto sin signo

2 0 a 65535

signed int Entero 4 -2147483648 a +2147483647

unsigned int Entero sin signo 4 0 a 4294967295

signed long Entero largo 4 -2147483648 a +2147483647

unsigned long

Entero largo sin signo

4 0 a 4294967295

signed char Carácter 1 -128 a 127

unsigned char

Carácter sin signo 1 0 a 255


Podemos ver que los datos enteros de tipo signed son equivalentes a los enteros sin utilizar el calificador:

signed int a; es equivalente a escribir int a;

Tipos de datos numéricos reales.

El tipo de dato numérico real es un subconjunto finito de los números reales. Pueden ser positivos o negativos.

En C++ los tipos de datos numéricos reales son los siguientes:

Tipo de Dato


Rango

float Real (Número en coma flotante)

4 Positivos: 3.4E-38 a 3.4E38 Negativos: -3.4E-38 a -3.4E38

Double

Real doble(Número en coma flotante de doble precisión)

8 Positivos: 1.7E-308 a 1.7E308 Negativos: -1.7E-308 a -1.7E308

long double

Real doble largo 10 Positivos: 3.4E-4932 a 1.1E4932 Negativos: -3.4E-4932 a -1.1E4932

Tipo lógico

Los datos de este tipo sólo pueden contener dos valores: true ó false (verdadero ó falso).

Si se muestran como enteros, el valor true toma el valor 1 y false el valor 0.

Tipo de Dato


Rango

bool Dato de tipo lógico 1 0, 1

Tipo carácter extendido

Este tipo se utiliza para representar caracteres UNICODE. Utiliza 2 bytes a diferencia del tipo char que solo utiliza 1.

Tipo de Dato


Rango

wchar_t

Carácter Unicode 2 0 a 65535


void: Tipo de dato que no tiene valor.

int: Para todo el rango de valores enteros*.

float: Para todo el rango de valores reales*.

char: Datos de tipo carácter.

Tipos de datos simples

Los tipos de datos simples en C son:

FUNCIONES

Las funciones son un conjunto de instrucciones que realizan una tarea específica. En general

toman ciertos valores de entrada, llamados parámetros y proporcionan un valor de salida o

valor de retorno; aunque en C++, tanto unos como el otro son opcionales, y pueden no existir.

Tal vez parezca un poco precipitado introducir este concepto tan pronto en el curso. Sin

embargo, las funciones son una herramienta muy valiosa, y como se usan en todos los

programas C++, creo que debemos tener, al menos, una primera noción de su uso. A fin de

cuentas, todos los programas C++ contienen, como mínimo, una función.

La función main()

La función main() en un programa en C significa el cuerpo del programa o el programa principal, ya que es la primer función que el enlazador busca para ejecutar; si la función main() no tiene parámetros, significa que solamente la utilizaremos para decirle al programa cuándo y cómo debe hacer las cosas, pero, si


tiene parámetros, es decir, si desde la línea de comando se llama con valores de entrada, la cosa cambia, y nos ocuparemos de la función main() con parámetros más adelante.

Funciones de E/S básicas

Las funciones de E/S son las que se utilizan para capturar datos desde el teclado e imprimirlos por medio de la salida estándar (monitor). Estas instrucciones soportan ciertos formatos:

La función scanf

La función scanf captura cualquier tipo de dato introducido por el teclado, y para esto, es necesario incluir en su llamada a función el formato o tipo de dato que se pretende leer por teclado, ejemplo:

scanf(“%d”,&x);

En este caso, se especifica una entrada de tipo decimal o entero (“%d”), mientras que el operador de dirección (&) indica que se debe guardar el valor en la localidad de memoria x, en otras palabras, indica que se recibirá un valor entero y se debe almacenar en la variable x. Ahora bien, los tipos de formato más usados para la instrucción scanf son:

%d, %i

Entero decimal con signo

%f Número real o flotante

%c Dato tipo caracter

%s Dato tipo cadena

%u Sin signo

La función printf

La función printf es la contraparte de la función scanf, ya que mientras scanf lee datos desde el teclado, la función printf los escribe, es decir, provee la salida en pantalla, esta función también utiliza los formatos de scanf, con la particularidad de que printf puede modificar la salida de los datos, por ejemplo, si se declara una variable entera, y se le asigna el valor 65, y al momento de imprimir el valor de la variable se especifica una salida de tipo caracter, la salida será el caracter “A” (el 65 equivale a la letra A en el código ASCII).

scanf(“%d”,&x); /* Se lee la variable como entera */

printf(“%c”,x); /* Se escribe como caracter */


LIBRERÍAS Y FUNCIONES

Las librerías son archivos que en C contienen las funciones que son las acciones que C nos

permite hacer estas son las librerías más usadas por que son librerías estándares de entrada

y salidas de datos tenemos la librerías.

stdio.h

se agrega asi:

#include<stdio.h>

Esta trae muchas funciones son estas (para acceder a la ayuda de turbo c ahí se puede

encontrar mucha información debes presionar F1 o sombrear una palabra y presionar ctrl +

F1 y te aparecerá la ayuda en relación a la palabra sombreada).

Otra función muy usada es la función scanf esta nos sirve para leer una variable (pedir un

valor al usuario) su sintaxis es así:

scanf("%d",&X);

x es la variable a la cual le vas a asignar el valor que se esta leyendo y en %d debe ser el tipo

de archivo que se quiere leer. Otra librería que también nos servirá de mucha utilidad es

conio.h

recuerda que las librerías se agregan al programa así:


#include<conio.h>

Esta librería trae estas funciones:

De las cuales las mas utilizadas son:

Clrscr

Esta función nos sirve para limpiar lo que este en la pantalla de nuestro programa

casis siempre lo debe llevar un programa para que no se acumulen los textos su

sintaxis es así:

clrscr();

cprintf esta es parecida a la función printf con la diferencia que esta es un poco mas

especial por ejemplo cuando le ponemos el modificador de texto \n no regresa al principio

de la línea sino se queda en al final del ultimo párrafo (tendrás que hacer pruebas para

entenderlo mejor) o si antes le antepones la función textcolor puedes modificar el color de

las letras.


su sintaxis es:

cprintf("texto");

sintaxis con la función textcolor

textcolor(numero);

cprintf(texto);

en donde dice numero puede ir un numero del 1 al 15, por ejemplo el numero 9 es el

color rojo.

La función getch sirve para detener la pantalla sin esta función no se puede apreciar

el programa por que pasa demasiado rápido pero, con getch para el programa para

apreciar el resultado hasta que se preciene una tecla normalmente va antes de

terminar el main .

su sintaxis es la siguiente:

getch();

Declaración de variables

Es necesario declarar las variables que se utilizarán en el programa, de modo que el compilador reserve un espacio en memoria para esas variables, la sintaxis es:

[tipo] [nombre_de_la_variable] [[dimension]] ; (la dimensión sólo se usa para arreglos).

Ejemplo:

int x;

int arreglo [100];

Y ya que hablamos de variables, cabe mencionar que las variables pueden ser declaradas globales o locales, solamente como referencia, las variables globales son aquellas variables que conservan su valor durante la ejecución de todo el programa y se declaran antes del main(), mientras que las variables locales solamente tienen valor durante la ejecución de la función o procedimiento en que fueron declaradas y se declaran después de la llave que indica el principio de una función o procedimiento. De cualquier manera, las diferencias entre las variables locales y globales serán objeto de estudio más adelante.


SINTAXIS DE LAS SENTENCIAS Y FUNCIONES DE C Para presentar los formatos de las sentencias, macros y funciones de C, se aplicarán, Cuando se trate de presentar la sintaxis correspondiente a una macro o a una Función, se dará la siguiente información: 1. Fichero de cabecera que contiene las declaraciones y definiciones relativas a

esa función y afines. 78 cunso DE PRocRAMACIóN c/c++

2. Prototipo de la función para indicar el tipo del resultado y el número y tipo de los argumentos.

3. Compatibilidad (ANSI, UNIX, MS-DOS). Por ejemplo, la sintaxis de la función sqrt (raíz ctadrada) es: #include <math.h> fichero de declaraciones y definiciones

double sqrt(double x); prototipo de 1a función

CompaLibilidadz ANSL, UNIX y MS-DOS

SENTENCIA DE ASIGNACION Una sentencia de asignación tiene la forma: Variable e operador-de-asignación expresión la sentencia de asignación es asimétrica. Esto quiere decir que se evalúa la expresión de la derecha y el resultado se asigna a la variable especificada a la izquierda. Por ejemplo:

totaf = O; area-3.I4L592*T*Ti

cuenta += 1; Según lo expuesto, la siguiente sentencia no sería válida: 3.L4L592*r*r=dr€di Si la variable es de Lipo puntero, solamente se le puede asignar una dirección de memoria, la cual será siempre distinta de 0. Un valor 0 (se simboliza con NULL) sirve para indicar que esa variable puntero no apunta a un dato válido. Por ejemplo: i¡¡¿=10,*p; P=&a; /* se asigna a p la dirección de a * /


No tiene sentido asignar un entero a una variable de tipo puntero. Cuando se asigna un valor a una variable estamos colocando el valor en una localización de memoria asociada con esa variable.

a -- 20:

ENTRADA Y SALIDA ESTANDAR Las operaciones de entrada y de salida (E/S) no forman parte del conjunto de sentencias de C, sino que pertenecen al conjunto de funciones de la biblioteca estándar de C. Por ello, todo fichero fuente que utilice funciones de E/S correspondientes a la biblioteca estándar de C, necesita de los prototipos de las funciones correspondientes a éstas, por lo que deberá contener la línea: #include "stdio.h" Las dobles comillas significan que el fichero especificado, debe ser buscado en el directorio actual de trabajo y si no se encuentra, la búsqueda debe continuar en el directorio estándar para los ficheros con extensión ./z (directoio include). Si el fichero de cabecera especificado, en lugar de escribirlo entre comillas, lo escribimos entre ánulos: #include <stdio.h> la búsqueda de dicho fichero se efectúa solamente en el directorio estándar para los ficheros con extensión.h (directono include).

Sentencia if

Las sentencias especifican y controlan el flujo de ejecución del programa. Si no existen el En C++ el concepto de bloque de sentencias se utiliza para agrupar un conjunto de sentencias dentro de un ambito 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 booleanas. Sintaxis:


if (<e ) < > else < > La sentencia else es opcional, puede utilizarse o no. En el ca

WHILE: El objetivo de un while es también un bucle de código; el bucle while funciona repitiendo su objetivo mientras la expresión sea cierta. Cuando ésta es falsa, el bucle se detiene. while (expresión) sentencia; El valor de la expresión se comprueba al principio del bucle, esto significa que, si la expresión es falsa al iniciarse, el bucle no se ejecutará ni una sola vez. #include<stdio.h> #include<conio.h> main() { char c; c= getch(); while (c!= `q'){ c= getch(); (“ ”);} } Ej: Programa que traduce los caracteres que se escriban a un formato codificado; anadiendo un 1 a cada letra. El programa se detiene cuando se pulsa intro. #include<stdio.h> #include<conio.h> main() { char c; (“I : \ ”); c= getch(); while (c!= `\n'){ (“% ” +1); c= getch(); } }


DO WHILE: El bucle do repite la/s sentencia/s mientras la expresión es verdadera, se detiene cuando la

expresión se convierte en falsa. El bucle do es único, ya que siempre ejecuta el código de dentro del bucle al menos una vez dado que la expresión que controla el bucle se

comprueba al final del mismo. do{ sentencias; }while (expresión);

Ej: Pide al usuarío qué quiere hacer con dos números. #include<stdio.h> #include<conio.h> main() { int a, b; char c; (“\n\nQuiere\ ”); (“S R M r o Dividir\ ”); do{ (“I z : \ ”); c=getch(); (“\ ”); }while (c!= `S' && c!= `R' && c!= `M' && c!= `D'); (“I z ú : \ ”); (“% ” & ); (“I z ú : \ ”); (“% ” &b); if (c== `S'){ (“% ” + ); else if (c== `R') (% ” -b); else if(c== `M') (“% ” * ) else if(c== `D') (“% ” / ); } } El bucle do es especialmente útil cuando el programa que está esperando a que ocurra un suceso.


CREACIÓN DE BUCLES ANIDADOS Cuando el cuerpo de un bucle contiene otro, se dice que el segundo está anidado en el primero. Cualquiera de los bucles de C puede estar anidado dentro de cualquier otro bucle. En C, el estándar ANSI especifica que los bucles pueden estar anidados hasta 15 niveles. Ej:Imprime en pantalla los números del 1 al 10. for(i=0;i<10;i++){ for(j=1; j<10; j++){ (“% ” ); } } Utiliza for para imprimir el alfabeto 3 veces, y cada vez las letras 2 veces. #include<stdio.h> #include<conio.h> main() { int i, j, k; for(i=0; i<3;i++){ for(j=0; j<26;i++){ for(k=0; k<2;i++){ (“% ” \'+j); } } } } UTILIZACIÓN DE BREAK PARA SALIR DE UN BUCLE Permite Salir de un bucle desde cualquier puntode su cuerpo, pasando por alto su espresión de finalización normal. Cuando break se encuentra dentro de un bucle, el bcle termina inmediatamente y el control del progranama continua en la sentencia que continua al bucle. Programa que imprima del 1 al 100 pero cuando llegue al 10 salte. #include<stdio.h> #include<conio.h> main() { int i; for(1=1;i<100;i++){ (“% ” ); if(i==10){ break; } } } La sentencia breaK se utiliza en bucles en los que una condición especial puede causar una terminación inmediata. Todos los numeros múltiplos de 6 #include<stdio.h>


#include<conio.h> main() { char c; int i; for(i=1;i<10000;i++){ if(!=(i%6)){ (“% ¿ ? (S/N)” ); c=getch(); if(c= `N'){ break; (“\ ”); } } } }

SWITCH:

Es una sentencia de selección múltiple de C. Se utiliza para elegir un camino entre varios caminos alternativos de la ejecución del programa y funciona asi: se compara una variable

con una lista de constantes enteras o de carácter, cuando concuerda con alguna se ejecuta la secuencia de sentencias asociadas con esa constante.

switch (variable){ case 1: secuencia de sentencias; break; … case n: secuencia de sentencias; break; default: secuencia de sentencias; break; } Donde la secuencia de sentencias de default se ejecutan si no coincide con ninguna de las otras. Default es opcional. Si no hay coincidencias y no existe el default, no se lleva a cabo ninguna opción. Cuando se encuentra alguna coincidencia, se ejecutan las sentencias asociadas con el `case' hasta que se encuentra con un `break', o en el caso de default o en el último case, hasta que se alcance el final del switch. Programa que recorre los numeros 1, 2, 3 y 4 e imprime el nombre del que se ha introducido: #include<stdio.h> main() {


int i; (“I 1 4: \ ”); (“% ” & ); switch(1){ 1: (“ ”); break; 2: (“ ”); break; 3: (“ ”); break; 4: (“ ”); break; default (“ ú ”); break; } } La sentencia `switch' se diferencia de `if' en que `switch' solamente puede verificar la igualdad, mientras que el `if', puede ser de cualquier tio, a demás, `switch' sólo funcionará con tipos int y char. Las secuencias de sentencias asociadas con cada case no son bloques, por lo tanto, no van encerrados entre llaves. El estándar ANSI estable que se permiten, por lo menos, 257 sentencias case. No puede haber dos constantes case con valores idénticos en el mismo switch. Es posible tener un switch como parte de una secuencia de sentencias de otro switch más externo, esto se llama switch anidado. Si las constantes case del switch más externo y más interno contienen valores comunes, no surgirá error. La sentencia switch se utiliza a menudo para procesar órdenes de menú. #include<stdio.h> #include<conio.h> main() { int a, b; char c; (“\n\n¿Quiere\nSumar, Restar, Multiplicar, Dividir?\ ”); do{ (“I z : “); c=getch(); (“\ ”); }while ((c!= `S')&&(c!= `R')&&(c!= `M')&&(c!='D')) (“I z : ·”); (“% ” & ); (“I z : ·”); (“% ” & ); switch (c){ S: (“% ” + ); break; R: (“% ” -b); break;


M: (“% ” * ); break; case D: if(b!=0){ (“% ” / ); break;} } } La sentencia `break' es opcional. Cuando no existe, la ejecución pasa al siguiente `case' y solo se detiene cuando encuentra una sentencia `break' o el final del switch. La sentencia de secuencias asociada a `case' puede estar vacía, esto permite que dos o mas `case' compartan una secuencia de sentencias común sin duplicación de código. #include<stdio.h> #include<conio.h> main() { char c; (“I : ”); c=getch(); switch (c){ case a: case e: case i: case o: case u: (“ \ ”); break; default: (“E ”); }

}

SENTENCIA FOR

Si necesitamos repetir un grupo de acciones un número conocido de veces la mejor opción es la sentencia repetitiva for().

for() es una de las sentencias repetitivas más usadas en los lenguajes de programación, esta sentencia inicializa una variable, evalúa una condición y luego realiza una operación sobre una variable.

Modo de uso:

for(inicialización;condición;operacion) {


//Acciones }

Secuencia:

1. Se inicializa la variable. 2. Se evalúa la condición. 3. Si la condición se cumple, se realizan las acciones especificadas, si no se

cumple, no se ejecuta ninguna acción y se salta a la próxima línea. 4. Se realiza una operación sobre una variable (incremento, decremento). 5. Se repiten los pasos 2, 3 y 4 mientras se cumpla la condición.

Ejemplos:

Escriba un programa en lenguaje C que solicite el ingreso de dos números (valor inicial y un valor final) y que muestre por pantalla los números que pertenecen al intervalo dado.

Solución:

#include <stdio.h> void main() { //Declaración de variables int inicial, final, i; //Solicitando y leyendo el ingreso de datos desde el teclado printf("Ingrese el valor inicial: "); scanf("%d",&inicial); printf("Ingrese el valor final: "); scanf("%d",&final); for(i=inicial;i<=final;i++) { printf("%d\n",i); //mostrando por pantalla los números desde //el valor inicial hasta el valor final } }

Contador: Un contador es una variable cuyo valor se incrementa o decrementa en una cantidad constante cada vez que se produce un determinado suceso o acción. Los contadores se utilizan con la finalidad de contar sucesos o acciones internas de un bucle; deben realizar una operación de inicialización y posteriormente las sucesivas de incremento o decremento del mismo. La inicialización consiste en asignarle al contador un valor inicial. Se situará antes y fuera del bucle.


estructura: int cont = 0 inicio del bucle i = i +1 fin del bucle

Acumulador: Es una variable que suma sobre sí misma un conjunto de valores para de esta manera tener la suma de todos ellos en una sola variable. La diferencia entre un contador y un acumulador es que mientras el primero va aumentando de uno en uno, el acumulador va aumentando en una cantidad variable.

FUNCIONES C++

Una función es un módulo de un programa separado del cuerpo principal, que realiza una tarea específica y que puede regresar un valor a la parte principal del

programa u otra función o procedimiento que la invoque.

La forma general de una función es:

Tipodato Nomfun(parametros)

{

cuerpo de instrucciones;

return [dato,var,expresion];

}

Donde tipodato especifica el tipo de dato que regresara la función.

La instrucción RETURN es quien regresa un y solo un dato a la parte del programa que la este llamando o invocando, sin embargo es de considerar que return puede regresar un dato, una variable o una expresión algebraica(no ecuación o formula)

como lo muestran los siguientes ejemplos;


a) return 3.1416;

b) return area;

c) return x + 15/2;

La lista de parametros formales es una lista de variables separadas por comas (,) que almacenaran los valores que reciba la funcion, estas variables actuan como locales dentro del cuerpo de la funcion.

Aunque no se ocupen parametros los paréntesis son requeridos.

Vectores, Matrices y Punteros en c++

VECTORES 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 despues de otro. A este grupo de elementos se les identifica por un mismo nombre y la posición en la que se encuentran. La primera posición del array es la posición 0. Podríamos agrupar en un array una serie de elementos de tipo enteros, flotantes, caracteres, objetos, etc.

Crear un vector en C++ es sencillo, seguimos la siguiente sintaxix:

Tipo nombre[tamanyo]; Ejm:

int a[5]; // Vector de 5 enteros float b[5]; // vector de 5 flotantes Producto product[5]; // vector de 5 objetos de tipo Producto Podríamos también inicializar el vector en la declaración:

int a[] = {5, 15, 20, 25, 30}; float b[] = {10.5, 20.5, 30.5, 12.5, 50.5} Producto product[] = {celular, calculadora, camara, ipod, usb} Como hay 5 elementos en cada array, automáticamente se le asignará 5 espacios de memoria a cada vector, pero si trato de crear el vector de la forma int a[] , el compilador mostrará un error, porque no indiqué el tamaño del vector ni tampoco inicializé sus elementos. Asigno valores a los elementos de un vector indicando su posición: int a[4] = 30; // le asigno el valor 30 a la posición 4 del vector. product[2].setPrecio(300) // le asigno un precio de 300 al producto en la posición 2.


Obviamente el método setPrecio() debe de estar implementado. Para llenar, recorrer e imprimir un vector podemos utilizar un bucle for:

#include <iostream> using namespace std; int main() { int dim; cout << "Ingresa la dimension del vector" << endl; cin >> dim; // Supongamos que ingrese 10 int vector[dim]; // mi vector es de tamanyo 10 for(int i = 0; i < dim; i++){ vector[i] = i * 10; cout << vector[i] << endl; } return 0; } La salida del programa mostrará: 0 10 20 30 40 50 60 70 80 90 Fàcil verdad? Bien ahora creen 2 o más vectores y empiecen a hacer funciones básicas como sumar, restar, buscar, ordenar, moda, etc que ayudan mucho a ir desarrollando la lógica. No vale copiar y pegar, mejor es practicar, practicar y practicar. Aquí una función simple para sumar 2 vectores a y b y poner el resultado en un tercer vector c:

#include <iostream> using namespace std; void sumar(int a[], int b[], int c[],int dim) { for (int i = 0; i < dim; i++) { c[i] = a[i] + b[i]; } } void imprimir(int v[], int dim) { for(int i = 0; i < dim; i++) { cout << v[i] << endl; } cout << endl << endl; } int main() { int dim; cout << "Ingresa la dimensión" << endl; cin >> dim; int a[dim];


int b[dim]; int c[dim]; for(int i = 0; i < dim; i++) { a[i] = i * 10; b[i] = i * 5; } cout << "Vector A " << endl; imprimir(a, dim); cout << "Vector B " << endl; imprimir(b, dim); sumar(a, b, c, dim); cout << "Vector C " << endl; imprimir(c, dim); return 0; } Si ingreso una dimensión de 10, este programa me daría: Vector A 0 10 20 30 40 50 60 70 80 90 VECTOR B 0 5 10 15 20 25 30 35 40 45 VECTOR C 0 15 30 45 60 75 90 105 120 135 Entonces para tomar en cuenta: Todo vector debe tener definido un tipo de dato. Todo vector necesita de una dimensión o tamanyo. El código de arriba se puede mejorar muchísimo con objetos y clases, este es solo un pequeño ejemplo.

MATRICES Una matriz es un vector de vectores o un también llamado array bidimensional. La manera de declarar una matriz es C++ es similar a un vector:

int matrix[rows][cols];

int es el tipo de dato, matrix es el nombre del todo el conjunto de datos y debo de especificar el numero de filas y columnas. Las matrices también pueden ser de distintos tipos de datos como char, float, double, etc. Las matrices en C++ se almacenan al igual que los vectores en posiciones consecutivas de memoria.


Usualmente uno se hace la idea que una matriz es como un tablero, pero internamente el manejo es como su definición lo indica, un vector de vectores, es decir, los vectores están uno detrás de los otros juntos. La forma de acceder a los elementos de la matriz es utilizando su nombre e indicando los 2 Subíndices que van en los corchetes. Si coloco int matriz[2][3] = 10; estoy asignando al cuarto elemento de la tercera fila el valor 10. No olvidar que tanto filas como columnas se enumeran a partir de 0. Bueno y para recorrer una matriz podemos usar igualmente un bucle. En este caso usando 2 for:

for(int i = 0; i < rows; i++) { for(int j = 0; j < cols; j++) { matrix[i][j] = i % j; } }

PUNTEROS El valor de todas las varíales que manejamos en nuestros programas se almacenan en memoria y tienen una dirección. Un puntero es una variable especial que apunta a la dirección de memoria de una variable. El puntero tiene a su vez su propia dirección. Todas estas direcciones tienen un formato hexadecimal. Los punteros son herramientas muy poderosas con muchas utilidades y enormes ventajas como veremos más adelante. A grandes rasgos, un puntero me permite desplazarme en la memoria, apuntar, re direccionar a ciertas variables, funciones, métodos, objetos, etc sin necesidad de mover grandes bloques de datos, lo cual nos ahorra muchísimo el consumo de memoria en los programas. Un puntero se debe declarar de acuerdo al tipo de dato al que apunta. Ejem:

int *var; // un puntero que puede apuntar a cualquier variable de tipo entero. char *u; // puntero de tipo char Persona *per; // puntero de tipo persona Para determinar, asignar la dirección de una variable en c++, se usa el operador & y para obtener el contenido de un puntero utilizamos el operador * Ejem:

int a; // entero int *b; // puntero a entero a = 20; // a tiene 20 b = &a; // asigno la dirección de a al puntero b cout << b << endl; // imprime la dirección de memoria de a; cout << *b; // imprime 20, osea el contenido de a Ahora analicemos las siguientes instrucciones y veamos como las variables van cambiando de valor en tiempo de ejecución:

#include <iostream> using namespace std; int main() {


int a; int b; cout << "Ingresa el valor de a: "; cin >> a; cout << endl; cout << "Ingresa el valor de b: "; cin >> b; cout << endl; // Punteros de tipo entero int *p; int *p2; cout << "Antes" << endl; cout << "Variable a = " << a << endl; cout << "Direccion de a = " << &a << endl << endl; cout << "Variable b = " << b << endl; cout << "Direccion de b = " << &b << endl << endl; // Tiene basura al principio, podria inicializar con *p=0 cout << "Contenido de p (Basura)= " << *p << endl; cout << "Direccion de p = " << &p << endl << endl; cout << "Despues" << endl; a++; p= &a; cout << "Contenido de p = " << *p << endl; // p ahora tiene la dirección de b p = &b; // Le sumo 20 al contenido de p, es decir, estoy incrementando el valor de b *p +=20; cout << "Variable a = " << a << endl; cout << "Variable b = " << b << endl << endl; // p ahora tiene la dirección de a p=&a; // Contenido de p es igual al contenido de a * 5 *p = a * 5; cout << "Contenido de p = " << *p << endl; cout << "Variable a = " << a << endl << endl; // Tiene basura al principio, podria inicializar con *p2=0


cout << "Contenido de p2 (Basura) = " << *p2 << endl; cout << "Direccion de p2 = " << &p2 << endl << endl; // El contenido de p es asignado al contenido de p2 p2 = p; // Incremento 15 al contenido de p2 *p2 += 15; cout << "Contenido de p2 = " << *p2 << endl; // p apunta a otra dirección de memoria,se desplaza 4 bytes en memoria p++; // El contenido de esa nueva dirección cout << "Contenido de p (Basura) = " << *p << endl; return 0; } La salida del programa: ANTES Variable a = 10 Direccion de a = 0x22ff74 Variable b = 2 Direccion de b = 0x22ff70 Contenido de p (BASURA) = -1017291943 Direccion de p = 0x22ff6c DESPUES Contenido de p = 11 Variable a = 11 Variable b = 40 Contenido de p = 55 Variable a = 55 Contenido de p2 (BASURA) = 2293680 Direccion de p2 = 0x22ff68 Contenido de p2 = 70 Contenido de p (BASURA) = 2293680 El contenido de p y p2 al principio es basura porque no tienen ningun valor asignado aun. Podriamos asignar el valor NULL a un puntero para luego posteriormente en algun problema que se me presente saber el estado del puntero y saber si contiene algo o no, así: int *p = NULL;

ARITMÉTICA DE PUNTEROS

En las últimas sentencias del programa anterior: p++; cout << *p pueden visualizar que estoy incrementando el puntero p en 1. Esto quiere decir que el puntero se desplazara 4 bytes en memoria (en este caso por ser entero) y entonces apuntará a otra dirección.


Por eso es que el nuevo contenido de p es basura o bueno el contenido de lo que tiene esa nueva dirección a la que apunta. Supongamos que definimos un entero y puntero de tipo char:

char c; char *d; d= &c; // asigno la direccion de c a d c = 'u'; // asigno el valor u a mi variable c c--; // desplazo una posicion a c cout << *d; N I ‘ ’ zé 1 y ( 1 byte). Es decir, que si d estaba apuntado a una dirección como por ejemplo 0x22ff99, despues del c– estará apuntando a algo como 0x22ff98 Para tomar en cuenta, cosas que no puedo hacer con punteros:

int a = 15; int *p; double *q; void *r; // No puedo hacer lo siguiente: p = a; // estoy asignando una variable a un puntero y un puntero es una dirección. p = &50; // 50 es un valor constante y no una variable, por lo tanto no tiene dirección. p = &(a+1); // una expresión no tiene dirección. p = 30; // igual que el primer error, 30 es un entero. &a = p; // no puedo cambiar la dirección de una variable. p = q; // p es puntero de tipo entero y q de tipo double. Un puntero de tipo void, es un puntero al cual le podemos asignar cualquier tipo de puntero. Por lo tanto si podriamos hacer esto: r = p; VECTORES Y PUNTEROS Cuando declaramos un vector int v[10] el nombre del vector, o sea v, es un puntero al primer elemento del vector, es decir a v[0]. Entonces como un vector es un puntero al primer elemento del mismo, también podríamos hacer aritmética de punteros con el vector.

(v + 1) ; // apunta a v[1]; *(v + 5); // me refiero al contenido de v[5] // Y también puede colocar índices a los punteros: int *p; // puntero de tipo entero p = &v[0]; // p apunta a la dirección del vector v[0] o también a v. p = v p[8] = 80; // le asigno el valor 80 al puntero en la posicion 8, es decir a v[8]

VECTORES DINÁMICOS


Un vector podría tener una cantidad variable de datos, a este se le llama un vector dinámico. Para usar vectores dinámicos necesitamos gestionar memoria dinámica. Si bien es cierto que es trae enormes ventajas, el hacer un mal uso de la memoria dinámica nos podría traer problemas desastrosos. Por eso es importante que cuando creemos vectores dinámicos también liberemos la memoria utilizada. Obviamente eliminaremos la memoria utilizada cuando ya no necesitamos más usar, en este caso, un determinado vector. El operador new sirve para reservar memoria dinámica. El operador delete se usa para liberar la memoria dinámica reservada con new. Para liberar memoria de un array dinámico usamos delete[] El espacio de memoria que hemos reservado con new tendrá vida hasta que finalice la ejecución del programa o cuando liberemos ese espacio con delete. Siempre es recomendable liberar memoria para posteriormente no tener problemas con excesivo consumo de memoria. Un simple ejemplo:

#include <iostream> using namespace std; int main() { int *pv; int dim; cout << "Ingresa el tamanyo del vector" << endl; cin >> dim; pv = new int[dim]; for(int i = 0; i < dim; i++){ pv[i] = i * i; cout << pv[i] << endl; } delete[] pv; return 0; }

MATRICES Y PUNTEROS

Supongamos que declaro una matriz int m[5][5] Como dijimos anteriormente, el nombre o identificador de un vector es un puntero al primer elemento del vector. En el caso de matrices el nombre de la matriz, en este ejemplo v, es un puntero que apunta al primer elemento del primer vector de la matriz. Entonces m es un doble puntero.m es igual a &m[0] que es igual a la direccion de &m[0][0].


Si declaramos un puntero int *pm y luego igualamos pm = m, p ahora puede desplazarse por los valores de m. *p; // contenido de m[0], el cual apunta al primer elemento de ese vector, es decir, m[0][0] También puedo referirme a los contenidos con aritmética de punteros:

/* desplazo una posición a p, se refiere al contenido de m[1], el cual apunta al primer elemento de ese vector, es decir, m[1][0] */ *(p + 1); /* desplazo una posición en el vector principal y este a su vez se desplaza una posición en ese vector, es decir, me refiero al contenido de m[1][1];*/ *(*(p + 1) + 1); p[2][4] = 20; // asigno el valor 20 a la posición 2,4 de la matriz *(*(p + 2) + 4) = 20 // es lo mismo que la asignación anterior *(pm[2] + 4) = 20 // también lo mismo // En conclusión: p[i][j] = *(*(p + i) + j) = *(pm[i] + j)

MATRICES DINÁMICAS

Para crear una matriz dinámica debemos de crear un doble puntero int **pm y samos al igual que los vectores el operador new para reservar memoria y delete para liberar. Primero tenemos que crear el vector que contendrá a otros vectores especificando el numero de vectores que tendra este vector principal. Ejem:

pm = new int* [rows]; // creo el vector de punteros principal for(int i = 0; i < rows; i++) { pm[i] = new int[cols]; // para crear los vectores dentro del vector principal } Un simple programa que crea una matriz dinámica, asigna valores, muestra el contenido de cada uno de los elementos los elementos así como sus direcciones de memoria. También mostramos la matriz usando aritmética de punteros:

#include <iostream> using namespace std; int main() { // Puntero a una matriz int **pm; int cols; int rows; cout << "Ingresa nro de filas: "; cin >> rows;

cout << endl; cout << "Ingresa nro de columnas: "; cin >> cols; pm = new int* [rows]; for (int i = 0; i < rows; i++) { pm[i] = new int[cols]; } cout << "Elementos de la Matriz con sus direcciones: " << endl; for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { pm[i][j] = i + j; cout << pm[i][j] << "--> "; cout << &pm[i][j] << endl; } cout << endl; } cout << endl; cout << "Elementos de la Matriz con sus direcciones, con aritmética de punteros: " << endl; for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { // Aritmética de punteros *(*(pm + i) + j) = i + j; cout << *(*(pm + i) + j) << "--> "; cout << &pm[i][j] << endl; } cout << endl; } // Elimino cada vector de la matriz for (int i = 0; i < rows; i++) { delete[] pm[i]; } // Elimino el vector principal delete[] pm; return 0;<!--EndFragment--}


ELEMENTO 2 EJERCICIOS C++

SENTENCIA IF

Programa N.-1 . - Diseñe un programa que me permita ingresar 3 números

enteros desde teclado que corresponden a 3 notas las mismas que deben estar

entre 1 y 10, obtenga el promedio correspondiente y determine su

equivalencia.

> Si el promedio es mayor o igual a 7, está aprobado.

> Si el promedio es mayor o igual a 5 y Menor que 7 esta suspenso


> Si el promedio es menor que 5 esta reprobado

Análisis:

Este programa nos sirve para obtener el promedio de un estudiante ya que cuando ingresemos las tres notas de un alumno nos pueda sacar la suma y el promedio donde si el promedio es mayor igual que 7 aprueba y si el promedio es mayor o igual a 5 y Menor que 7 está en suspenso y si el promedio es menor que 5 reprobado.

CODIFICADO:

#include <stdio.h>

#include <conio.h>

int a,b,c,s,p;

void main()

{

clrscr();

gotoxy(35,4);

printf(">>>PROMEDIO<<<") ;

gotoxy(10,8);printf("Ingrese 1 notas: ");

scanf("%d",&a);

Las librerías sirven

para llamar a las

funciones que se

desea

Es el inicio de la

ejecución del

programa

Sirve para declarar

las variables

Es para abrir el

programa

Limpia la pantalla

Es para la ubicación

de las filas y las

columnas Imprime los valores o

expresiones que se le

da

Lee el dato que se le

da

Es para ingresar los


gotoxy(10,10);printf("Ingrese 2 notas: "); scanf("%d",&b);

gotoxy(10,12);printf("Ingrese 3 notas: "); scanf("%d",&c);

s=a+b+c;

p=s/3;

if (p>=7 && p<=10)

{

gotoxy(15,15);printf("APUEBA");

}

Else

if(p>=5 && p<=6

{

gotoxy(15,15);printf("SUSPENSO");

}

else

{

if(p>=1 && p<=4)

{

Limpia la pantalla

Hace el proceso

para sacar la

suma de las notas

Es el proceso

para sacar el

promedio de las

Es una condición donde se

ejecuta solamente si la

expresión es verdadera.

Es una condición que se

formula dentro de la





gotoxy(15,15);printf("PIERDE");

} }}

getch();

}

CORRIDO:

PROGRAMA N.-2.- Diseñe un programa que me permita ingresar un número

entero desde teclado desde 1 al 7 y que determine o visualice el nombre del día

de la semana que corresponda

ANALISIS:

En este programa nos sirve para que pueda sacar los días de la semana donde la

condición es que ingresemos un numero entero del 1 al 7 y que el número que

digitemos nos debe salir el día que corresponda.

CODIFICADO:

#include<stdio.h>

#include<conio.h>

#include<stdlib.h>

Espera a que se presione

cualquier otra tecla para

finalizar

Ciera el

programa


para llamar a las

funciones que se

desea

Funciones estándar

http://www.monografias.com/trabajos33/programacion-lenguaje-c/programacion-lenguaje-c.shtml#ixzz2igZ4DD00






void borde()

{

int i;

clrscr();

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

{

gotoxy(i,3);printf("*");

gotoxy(i,20);

printf("*");

}

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

{

gotoxy(5,i);printf("*");


}

}

int a;

main ()

{

Es el inicio de la

ejecución del

Sirve para

declarar las

Es para abrir el

programa

Limpia la pantalla

Se mostrarán los 4

bordes

Indica las veces debe

repetirse una

condición

Para la ubicación de las

filas y las columnas

Imprime los valores

o expresiones que se

le da

Sirve para

declarar las


clrscr();

borde();

gotoxy(35,5);printf("DIAS DE LA SEMANA");

do

{

gotoxy(29,5);printf(" ");

gotoxy(15,7);printf("Ingrese un numero: ");

scanf("%d",&a);

}

while(a<1 || a>7);

switch(a)

{

case 1:

gotoxy(35,10);printf("LUNES");

break;

case 2:

gotoxy(35,10);printf("MARTES");

break;

case 3:

Llama al borde

Es el que te permite

elegir más de dos vías de

Este es mientas cumpla

la condición

Es para que cumpla una

condición y tiene retorno

Al final de las acciones

Es evaluar varias condiciones y

devolver un valor único para

cada condición.


gotoxy(35,10);printf("MIERCOLES");

break;

case 4:

gotoxy(35,10);printf("JUEVES");

break;

case 5:

gotoxy(35,10);printf("VIERNES");

break;

case 6:

gotoxy(35,10);printf("SABADO");

break;

case 7:

gotoxy(35,10);printf("DOMINGO");

break;

}

getch();

Corrido:



finalizar

Cierra el programa }

Impresión de

datos







PROGRAMA N.-3.- 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.

ANALISIS:

En este programa es el que nos ayuda a obtener las comisiones que una empresa

tiene de las ventas que ha realizado en donde podemos sacar lo siguiente si >=

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%; ya que

también este programa me da la opción donde puedo realizar el proceso las veces

que el usuario lo desea

CODIFICACION:

#include<stdio.h> Las librerías sirven para

llamar a las funciones

que se desea


#include<conio.h>

#include<string.h>

main()

{

int tv, c, totv=0, totc=0;

char aux='s';

while (aux=='s')

{

clrscr();

gotoxy(32,2);

printf("EMPRESA DE VENTAS XYZ");

gotoxy(5,5);printf("INGRESE EL TOTAL DE LAS VENTAS: ");

scanf("%d",&tv);

Es el inicio de la

ejecución del programa

Sirve para declarar las

variables

Limpia la pantalla

Es para abrir el

programa


la condición


de las filas y las

Imprime los valores o



da




Es el que realiza una

declaración

Manejo de cadenas


if(tv>=3000 && tv<=5000)

{

c=tv*0.05;

}

else

{

if(tv>5000 && tv<=8500)

{

c=tv*0.07;

}

else

{

if(tv>8500 && tv<=10000)

{

c=tv*0.08;

}

else

{

if(tv>10000)

{

c=tv*0.10;

} } } }

totv=totv+tv;

totc=totc+c;

Es una condición que se

formula dentro de la

Es un proceso donde va

contando el total de las

Este realiza un proceso de ir

sumando el total de las

ventas más el total de la

SENTENCIAS

CONDICIONANTES


gotoxy(5,7);printf("TOTAL DE LAS COMISIONES ENTREGADAS:

%d",c);

gotoxy(5,10);printf("TOTAL DE LA VENTA: %d",totv);

gotoxy(5,12);printf("TOTAL DE LAS COMISIONES: %d",totc);

gotoxy(2,15);printf("DESEA INGRESAR UNA NUEVA VENTA s/n:

");scanf("%s",&aux);

}

getch();

return 0;

}

CORRIDO:

PROGRAMA N.-4.- Diseñe un programa que me permita ingresar 2 números por

teclado y realizar la suma de los mismos.



finalizar

Cierra el

programa







ANALISIS:

Este programa nos sirve para poder sacar la suma de dos números cualquiera

donde el usuario puede ingresar por teclado los numero que desea para que la

computadora realice el proceso para poder sacar el resultado de la suma

CODIFICACION:

#include<stdio.h>

#include<conio.h>

#include<string.h>

void main()

{

int a, b, suma;

clrscr();

gotoxy(15,3);

printf("SUMA DE DOS NUMEROS");


gotoxy(10,5); printf("INGRESE EL PRIMER NUMERO: ");

scanf("%d",&a);

}


Es el inicio de la

ejecución del

Sirve para

declarar las

Limpia la pantalla


de las filas y las

Es para abrir el

programa




da


para llamar a las

funciones que se desea

Manejo de cadenas


gotoxy(10,7);printf("INGRESE EL SEGUNDO NUMERO:

");scanf("%d",&b);

suma=a+b;

gotoxy(10,9);printf("LA SUMA ES: %d",suma);

getch();

}

CORRIDO:

PROGRMA N.-5 Realice la suma de 2 números siempre que el primer valor este

entre 3 y 23 y el segundo valor este entre 5 y 17.

ANALISIS:

En este programe lo que nos pide es que si el primer número que ingresamos pro

teclado tiene que tener una condición que tiene que estar entre 3 y 23 y el segundo

número que ingrese tiene que tener la siguiente condición que tiene que estar entre

5 y 17 y si ingresamos un numero de las dos condiciones que tenemos nos sale

erros y si ingresamos los números que están dentro de esa condición se nos realiza

la suma normal también se puede realizar las veces que uno quiera

CODIFICACION:

#include<stdio.h>

#include<conio.h


para llamar a las




finalizar

Cierra el programa







#include<string.h>

void main()

{

int a, b, suma, op;

do

{

clrscr();

gotoxy(15,3);

printf("SUMA DE DOS NUMEROS");

do

{


gotoxy(10,5); printf("INGRESE EL PRIMER NUMERO: ");

scanf("%d",&a);

Es el inicio de la

ejecución

Sirve para

declarar las


condición y tiene retorno

Limpia la pantalla


de las filas y las

Es para abrir el

programa




da

Manejo de cadenas


}

while(a<3 || a>23);

do

{ gotoxy(37,7);printf(" ");

gotoxy(10,7);printf("INGRESE EL SEGUNDO NUMERO: ");

scanf("%d",&b);

}

while(b<5 || b>17);

suma=a+b;

gotoxy(10,9); printf("LA SUMA ES: %d", suma);

gotoxy(10,13);printf("PRESIONES 1 PARA CONTINUAR O 0 PARA

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

}

while(op==1);

getch();

}

CORRIDO:


la condición


condición y tiene



finalizar

Cierra el programa







PROGRAMA N.-6. Diseñe un programa que me permita ingresar el nombre de

una persona y la edad de la misma que debe estar entre 3 y 85, para obtener

las siguientes equivalencias:

Si la edad está entre 3 y 5 debe visualizarse: nombre, “es un bebé”

Si la edad es > 5 y <13 debe visualizarse: nombre, “es un niño”

Si la edad es > 13 y ≤ 21 debe visualizarse: nombre, “es un adolescente”

Si la edad es > 21 y ≤ 60 debe visualizarse: nombre, “es un adulto”

Si la edad es > 60 debe visualizarse: nombre, “es un adulto mayor”

El programa se repite tantas veces como el usuario lo desee.

ANALISIS:

En este programa presentado, tenemos que utilizar una variable “op” que se utilizara

para la opción desea continuar SI o NO, esto se lo realiza con el Laso DO – WHILE

que permite generar nuevamente el programa. Utilizamos el “if “para realizar la

condición y si es la condición es verdadera me imprima el mensajes que deseo que

me aparezca en el programa.

CODIFICACION:

#include<stdio.h>

#include<conio.h>

#include<string.h>

main ()

{

int ed, op;

char nom[25];

do

{

clrscr();

gotoxy(15,2);printf("EQUIVALENCIA DE LAS EDADES");

Librerías tipos usados por varias operaciones de entrada y salida, es

un comentario

Para iniciar el programa

Abrir el programa

Definición de variables: antes de realizar algunas operaciones en

el programa se debe declarar las variables que se utiliza

Cargar o inicializar variable de condición

Borra todo el contenido de la pantalla

Imprime el mensaje


gotoxy(5,5);printf("INGRESE EL NOMBRE: ");scanf("%s",&nom);

do

{

gotoxy(22,7);printf("INGRESE SU EDAD: ");scanf("%d",&ed);

gotoxy(5,7);printf("INGRESE SU EDAD: ");scanf("%d",&ed);

}

while(ed<3 && ed>85);

if(ed>=3 && ed<=5)

{

gotoxy(7,10);printf("ES UN BEBE");

}

else

{

if(ed>5 && ed<=13)

{

gotoxy(7,10);printf("ES UN NINO");

}

else

{

if(ed>13 && ed<=21)

{

gotoxy(7,10);printf("ES ADOLESCENTE");

}

else

{

if(ed>21 && ed<=60)

{


Es para ingresar los

datos

Rompimiento del ciclo

Si la condición es verdadera, y

comienza a realizar el proceso

Realiza el proceso

Realiza el proceso del programa e

impresiones de los resultados


gotoxy(7,10);printf("ES ADULTO");

}

else

{

if(ed>60)

{

gotoxy(7,10);printf("ES ADULTO MAYOR");

}

}

}

}

}

gotoxy(10,13);printf("PRESIONES 1 PARA CONTINUAR O 0 PARA SALIR:

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

}

while(op==1);

getch();

}

CORRIDO:

Cierre de los if

Rompimiento del ciclo

Retorna el carácter leído desde

teclado

Cierres del programa


PROGRAMA 7. Diseñe un programa que me permita simular la venta

de productos en una factura, de la cual necesitamos ingresar el

nombre del producto, la cantidad, precio unitario y calcular el precio

total. El programa se repite n veces según los productos que el usuario

desee ingresar.

ANALISIS:

En este programa realizamos una factura con diseño incluido utilizamos variables

como “int, float, char “las de tipo “float” nos sirve para cantidades con decimales y las

“char” para ingresar el detalle de la factura, utilizamos un for para el diseño de la

estructura del margen de la factura, también un lazo DO-WHILE par realizar de

nuevo el programa, y un “if “para las condiciones respectivas en cada literal,

tenemos variables para almacenar los cálculos respectivos.

CODIFICACION:

#include<stdio.h> Librerías tipos usados por varias operaciones de entrada y salida, es un

#include<conio.h> compilador

void main() void=para iniciar el programa

{ Abrir el programa

int i,op; Para almacenar valores entero

float cant,uni,vt,iva,total,sub; Para almacenar datos decimales

char det[15],preg[2]; Para almacenar caracteres

clrscr(); Borra todo el contenido de la pantalla

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

{



} Diseño de la estructura del margen

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

{



}

gotoxy(35,2);printf("=============");

gotoxy(35,3);printf("F A C T U R A");

gotoxy(35,4);printf("=============");

gotoxy(15,6);printf("CANT DETALLE V.UNIT V.TOTAL"); Diseño de la

gotoxy(14,7);printf("==================================="); portada

gotoxy(43,21);printf(" Subtotal");

gotoxy(43,22);printf(" IVA 12% ");

gotoxy(43,23);printf(" Total");


i=8; Se ingresa los valores de la fila 8

sub=0;

do El lazo do while primero realiza la acción y luego pregunta la prueba de condición es

{ hecha al finalizar el ciclo

gotoxy(15,i); scanf("%f",&cant); Es para ingresar los datos

gotoxy(27,i); scanf("%s",&det);

gotoxy(42,i); scanf("%f",&uni);

vt=cant*uni; Proceso para realizar el calculo

gotoxy(54,i); printf("%4.2f",vt); Imprime el valor total

gotoxy(5,23); printf("Desea ingresar otro producto: "); scanf("%s",&preg);

if(preg[0]=='s')

{ Si la condición es verdadera

op=1;

i=i+1; Para que sume las filas

}

else

{ Si la condición es falsa

op=0;

}

sub=sub+vt;

} Realiza el proceso del programa

while(op==1);

iva=0.12*sub;

total=sub+iva;

gotoxy(54,21); printf("%4.2f",sub);

gotoxy(54,22); printf("%4.2f",iva); Para imprimir los valores

gotoxy(54,23); printf("%4.2f",total);

getch(); Retorna el carácter leído desde teclado

} programa Se cierra el


CORRIDO:

PROGRAMA N.-9 Diseñe un programa que me permita calcular el promedio

general de las notas de distintas materias correspondientes al 2º Semestre de

Docencia en Informática, en donde cada una de las notas ingresadas debe estar

entre 1 y 10.

Análisis:

En este programa deseamos encontrar el promedio general del curso para lo q utilizamos

z “ DO- WHILE” 1 10

#include<conio.h>

#include<stdio.h>

void main()

{

char no[15];

int op,c=0,d;

float n1,n2,n3,fla=6;

float p,pg=0;

clrscr();

gotoxy(25,2);printf("Facultad de Ciencias Humanas");

gotoxy(27,3);printf("Segundo Informática");

gotoxy(10,5);printf("Módulos Nota1 Nota2 Nota3 Promedio");

do

Librerías tipos usados por varias operaciones de

entrada y salida un compilador Abrir el programa

Inicia el programa

Definición de variables: antes de realizar algunas

operaciones en el programa se debe declarar las

Borra la pantalla Imprime mensajes y

para la

presentación del Cargar o inicializar

variable de condición


{

c=c+1;

flushall();

gotoxy(10,fla);gets(no);

do

{

gotoxy(27,fla);printf(" ");

gotoxy(27,fla);scanf("%f",&n1);

}while(n1>10 || n1<1);

do

{



}while(n2>10 || n2<1);

do

{



}while(n3>10 || n3<1);

p=(n1+n2+n3)/3;

pg=pg+p;

gotoxy(54,fla);printf("%2.2f",p);

gotoxy(10,15);printf("%2.2f",pg);

fla=fla+1;

gotoxy(10,10);printf("Presione 1 para continuar o 0 para salir: ");scanf("%d",&op);

}while(op==1);

d=pg/c;

gotoxy(10,16);printf("g%d",d);

getch();

}

CORRIDO:

Utiliza un contador

Cargar o inicializar

variable de condición

Ingresa la primera nota

Aquí cierra la condición

que debe estar entre 1

hasta 10 Cargar o inicializar

variable de condición Ingresa la segunda

nota Aquí cierra la condición


hasta 10

Ingresa la tercera nota

Aquí cierra la condición


Realiza el cálculo del

promedio

Aquí nos imprime las notas del

programa

Nos pide la

opcion Cierra la condición

Imprime el promedio general


teclado Cierra el programa


PROGRAMA N.-9 Realice un programa en C++ que me permita obtener

el líquido a recibir de un empleado bajo los siguientes parámetros: El empleado percibe un salario mínimo vital el mismo que depende de su categoría, existen

3 posibles alternativas, este datos deberá ser ingresada al inicio del programa

conjuntamente con el nombre del empleado:

Categoría 1 180,00

Categoría 2 250,00

Categoría 3 380,00

A este salario mínimo vital se le incluye algunos rubros que son:

1. Horas extras, las mimas que no pueden exceder 8, cada hora extra cuesta Usd. 1,80.

2. Bono familiar la misma que está condicionada. Si el empleado tiene más de dos hijos

se le paga Usd. 4,50 por cada hijo caso contrario se le reconoce Usd. 6,20 por cada

hijo.

3. Obtenga el valor del IESS que es el 11,5 % del nominal


4. Se le descuenta el 2% del nominal como aporte a la asociación

5. Obtenga los valores correspondientes de ingresos, egresos y total a recibir.

El programa se genera n veces.

ANALISIS:

En este programa que hemos elaborado para sacar el líquido a recibir de un empleado,, tenemos que

z “ ” z ó SI NO z

con el Laso DO – WHILE z “ ”

condicionar las horas extras y para escoger la categoría del empleado y acumuladores para realizar

cálculos

CODIFICACION:

Programa:

/*Obtener el líquido de un empleado*/

#include<conio.h>

#include<stdio.h>

main()

{

int a,b,horax,bonofo,sue,op=0;

float c,d,iees,aso,ingre,egreso,tot;

char nom[10];

clrscr();

do

{

gotoxy(27,2);

printf("++ROL DE PAGOS++");

gotoxy(20,4);

printf("Ingrese el nombre del empleado: ");

scanf("%s",& nom);

gotoxy(27,6);

printf("**Categoria**");

gotoxy(20,8);

printf("categoría 1=180 categoría 2= 250 categoría 3=380" );

gotoxy(20,10);

printf("Ingrese la Categoría que desee: ");

scanf("%d",&a);

gotoxy(20,12);

printf("Ingrese número de hijos que tiene: ");

scanf("%d",&b);

Comentarip del programa

Librerías tipos usados por varias operaciones

de entrada y salida, es un comentario Para iniciar el programa

Para abrir el programa

Definición de variables: antes de realizar algunas

operaciones en el programa se debe declarar las

variables que se utiliza Borra la pantalla


Impresión de mensaje

Imprime el mensaje

Ingresa datos

Imprime el mensaje

Da posicionamiento en donde desee aparecer el

mensaje

Diseño del programa


gotoxy(20,14);

printf("Ingrese las horas extras: ");

scanf("%d",&horax);

if(horax>0 && horax<=8)

{

d=horax*1.80;

}

if(b>0 && b<=2)

{

c=6.20*b;

}

else

c=4.50*b;

if (a==1)

{

iees=0.115*180;

aso=0.02*180;

sue=180;

ingre=sue+c+d;

egreso=aso+iees;

tot=ingre-egreso;

gotoxy(23,15);

printf("INGRESO");

gotoxy(24,16);

printf("*Sueldo= %.d",sue);

gotoxy(24,17);

printf("*Horas Extras= %.2f",d);

gotoxy(24,18);

printf("*Bono Familiar= %.2f",c);

gotoxy(27,19);

printf("TOTAL INGRESOS= %.2f",ingre);

gotoxy(23,20);

printf("EGRESOS");

gotoxy(24,21);

printf("*Aporte al Iess= %.2f",iees);

gotoxy(24,22);

printf("*Aporte Asociación= %.2f",aso);

gotoxy(27,23);

printf("TOTAL EGRESOS= %.2f",egreso);

gotoxy(29,24);

printf("LIQUIDO A PAGAR= %.2f",tot);

Realiza el proceso del programa

Imprime los resultados

obtenidos del programa

Imprime los resultados obtenidos

del programa


}

if (a==2)

{

iees=0.115*250;

aso=0.02*250;

sue=250;

ingre=sue+c+d;

egreso=aso+iees;

tot=ingre-egreso;

gotoxy(23,15);

printf("INGRESO");

gotoxy(24,16);


gotoxy(24,17);


gotoxy(24,18);


gotoxy(27,19);


gotoxy(23,20);

printf("EGRESOS");

gotoxy(24,21);


gotoxy(24,22);


gotoxy(27,23);


gotoxy(29,24);


}

if(a==3)

{

iees=0.115*380;

aso=0.02*380;

sue=380;

ingre=sue+c+d;

egreso=aso+iees;

tot=ingre-egreso;

gotoxy(23,15);

printf("INGRESO");

gotoxy(24,16);


Imprime resultados

Imprime resultados




gotoxy(24,17);


gotoxy(24,18);


gotoxy(27,19);


gotoxy(23,20);

printf("EGRESOS");

gotoxy(24,21);


gotoxy(24,22);


gotoxy(27,23);


gotoxy(29,24);


gotoxy(30,24);

printf("Desea ingresar otro empleado digite 1");

gotoxy(30,25);

printf(" Desea salir del programa digite 0");

gotoxy(30,26);

printf("Ingrese la op= ");scanf("%d",&op);

}

} while (op==1);

getch();

return 0;

CORRIDO:

Imprime los resultados del programa

Nos imprime el mensaje para escoger

la opción que deseemos esoger

Rompimiento del ciclo Retorna el carácter leído desde teclado

Cierra el programa


PROGRAMA N.-10. Diseñe un programa que me permita imprimir un borde de

pantalla.

ANALISIS:

El progra z “ ” z

opción desea continuar SI o NO, esto se lo realiza con el Laso DO – WHILE que permite

generar nuevamente el programa. Utilizamos el lazo for para generar el borde en la pantalla.

CODIFICADO:

#include<stdio.h>

#include<conio.h>

void main () Librerías tipos usados por varias operaciones de entrada y salida, es un

comentario

librerías

Para iniciar el programa


{

int n,fila,i,op=1;

do

{

clrscr();

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

{



}

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

{



}

gotoxy(28,5);printf("ingrese el límite: ");

scanf("%d",&n);

fila=6;

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

{

gotoxy(20,fila);printf("%d",i);

fila=fila+1;

}

fila=6;

for(i=1;i<=n;i+=2)

{

gotoxy(50,fila);printf("%d",i);

fila=fila+1;

}

gotoxy(20,25);printf("desea continuar");

scanf("%d",&op);

}while(op==1);

getch();

}

CORRIDO:

Para abrir el programa Declaración de variables

Lazo do while inicia la condición

Borra la pantalla

Proceso

Imprime el margen

Cierra el for

Proceso

Imprime el margen

Imprime el mensaje

Ingresa datos

Indica el límite

Imprime el resultado

Utiliza un contador

Indica el límite

Imprime el resultado

Imprime el mensaje para escoger la opción

Finaliza el lado while


Cierra el programa


PROGRAMA N.-11.- Diseñe un programa que me permita imprimir un borde de

pantalla

Análisis: Este programa nos permite generar un margen o borde en pantalla

para mejorar la presentación en pantalla.


Codificación:

#include<stdio.h>

#include<conio.h>

main()

{

int i;

clrscr();

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

{

gotoxy(i,1);

printf("*");


}

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

{



}

getch();


para llamar a las


Sirve para declarar

las variables

Es el inicio de la

ejecución del

Limpia la pantalla

Inicio de un ciclo

con un límite


de las filas y las



Inicio de un ciclo

con un límite



finalizar







}

Corrido:


números pares

Análisis: este programa nos va a generar el borde en pantalla así como

también generara los números pares ingresando un límite ingresando

desde teclado.

Corrido:

#include<stdio.h>

#include<conio.h>

main()

{

Ciera el

programa


para llamar a las


Es el inicio de la

ejecución del


int i;

clrscr();

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

{

gotoxy(i,1);

printf("*");


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

{



}

y(28 3); (“… SERIE DE NUMEROS PARES …”);

g y(3 5); (“INGRESE EL LIMITE::”); (“% ” & );

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

{

gotoxy(col,11); (“% ” 2);

col=col+4;

}

y(3 22); (“PRESIONE UNO PARA VOLVER A REPETIR EL

PROCESO O 0 PARA FINALIZAR::”); (“% ” );

Sirve para declarar

las variables

Limpia la pantalla

Inicio de un ciclo

con un límite


de las filas y las



Inicio de un ciclo

con un límite

Acumulador para que

vaya dando espacios

Mensaje para continuar o

terminar el programa


}

While(op==1)

getch();

}

3.- CORRIDO


números pares y los impares que existen hasta el número límite ingresado desde teclado.

ANALISIS: este programa nos ayuda a generar números pares e impares y a

la vez nos genera el borde.

Codificación:

#include<conio.h>

#include<stdio.h>

Cierre del ciclo while

Finalización del

programa

Las librerías sirven para

llamar a las funciones

que se desea


void main()

{

int limite,i,fla,op; clrscr();

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

{



}

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

{



}

gotoxy(25,5);printf("Series");

gotoxy(15,6);

printf("Ingrese limite: ");

scanf("%d",&limite);

fla=6;

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

{

gotoxy(20,fla+1);printf("%d",i);

Sirve para declarar

las variables

Es el inicio de la

ejecución del

Inicio de un ciclo

de contiene un

Inicio de un ciclo

de contiene un

Imprime un

mensaje

Lee datos o

ingresa

Igualación desde

una cierta

contador


fla=fla+1;

}

fla=7;

for(i=1;i<=limite;i+=2)

{

gotoxy(40,fla);printf("%d",i);

fla=fla+1;

}

getch();

}

3.- CORRIDO

PROGRAMA N.-14.- Diseñe un programa que me permita generar las

tablas de multiplicar de cualquier factor ingresado desde teclado y por

cualquier limite ingresado desde teclado, el programa se genera n

veces, diseñe el borde en pantalla.

ANALISIS: este programa genera el borde como también genera la tabla de

multiplicar ingresando por teclado el número y el límite.

Finalización del

programa


Codificación:

#include<conio.h>

#include<stdio.h>

void main()

{

int i,f,l,d,op;

do

{

clrscr();

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

{



}

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

{



}

gotoxy(15,2);printf("Tabla de multiplicar");

gotoxy(10,3);

printf("Factor: ");

scanf("%d",&f);

gotoxy(10,4);printf("Limite: ");scanf("%d",&l);

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

{

d=f*i;

gotoxy(10,4+i);printf("%d",f);

gotoxy(18,4+i);printf("%d",d);

gotoxy(12,4+i);printf("*");

gotoxy(16,4+i);printf("=");

gotoxy(14,4+i);printf("%d",i);

}

gotoxy(15,20);printf("Desea salir 1/0: ");scanf("%d",&op);

LIBRERIAS

HABILITA

Inicio de un

programa Declaración de

variables

Inicio de while nos

ayuda a repetir

varias veces el

programa

Inicio de un ciclo

con limite

Cierre del ciclo

Genera ubicación

Inicio de un ciclo

de contiene un

Imprime mensajes

Permite ingresar

datos

operaciones


}while(op==1);

getch();

}

3.- CORRIDO DEL PROGRAMA

Programa 15

Enunciado: Diseñe un programa que me permita visualizar la factorial de un número ingresado desde

teclado.

Codificado

#include<stdio.h>

#include<conio.h>

#include<string.h>

main()

{

int i, fact=1, num, fila=6, op;

Cierre del ciclo

while

Cierre del

programa

Las librerías sirven para llamar a las funciones que se desea

Es el inicio de la ejecución

Es para abrir el programa

Sirve para declarar las


do

{

fila=6;

fact=1;

clrscr(); limpia la pantalla

gotoxy(31,2);printf("FACTORIAL DE UN NUMERO"); imprime el titulo

for(i=1;i<=80;i++) inicializa el for

{ llaves de inicio del for

gotoxy(i,1);printf("*"); impression de *


} finalize el for

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

{ llave de inicio del for


gotoxy(80,i);printf("*"); imprime *

} finaliza el ciclo for

gotoxy(3,4);printf("Ingrese un numero: ");scanf("%d",&num); imprime y lee variables

for(i=1;i<=num;i++) inicia el for hasta num

{ llave de inicio de for

fact=fact*i; contador

gotoxy(3,fila);printf("Factorial de %d: %d",i,fact); inpresion de resultados

fila=fila+1; contador de dila

} cierra llaves de for

gotoxy(3,23);printf("PRESIONE 1 PARA CALCULAR OTRO FACTORIAL O 0 PARA

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

} cierre de do

while(op==1); reconoce la opcion

getch(); pausa

} finalisa el programa

1. Corrido del Progrma:

Es para que cumpla una condición y tiene retorno

Es para que cumpla una condición y tiene retorno


4.-Analisis del Programa:

Este programa nos permite realizar los números factoriales se peuden repetir n veces del

numero que le ingresemos.

Programa 16

1.- Enunciado:

Diseñe un programa que me permita generar una serie de números, en donde el numerador es

cualquier factor ingresado desde teclado, y el numerador es la serie de los números impares.

2.- Codificado:

#include<stdio.h>

#include<conio.h> activación de librerias

#include<string.h>

main() cabeza del programa

{ llave de inicio de programa

int i, j, np, cont=0, c=10, res, op, col=15, imp=1; declaracion de variables

do inicio del ciclo do

{ llave de inicio

imp=1; inicializo imp en 1

col=15; columna en 15

c=10; c en 10


clrscr(); borrado de pantalla

gotoxy(30,3);printf("SERIE PRIMOS/IMPARES"); inpresion del titulo

for(i=1;i<=80;i++) inicia for



gotoxy(i,24);printf("*"); impresion de *

} cierre del ciclo

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

{ inicio


gotoxy(80,i);printf("*"); impresion de*

}

gotoxy(3,5);printf("Limite: ");scanf("%d",&np);

gotoxy(10,7);printf("1"); lectura e impresion de datos

gotoxy(8,6);printf("Serie: ");

for(i=1;i<=np;i++) condicion del for

{ llave de inicio de for

cont=0; inicia el contador en 0

for(j=1;j<=i;j++) condicion del for


res=i%j; proceso

3.- Corrido de programa

4.- Análisis del Programa:


Este programa lo generamos el numerador se imprimen los números primos y en el

denominador los impares se repetirán las veces que nosotros queramos.

Programa 17

Diseñe un programa en C++ que me permita generar n números primos, el proceso se repite n

veces y se visualiza el borde de pantalla.

2.- Copdificado

#include<conio.h>

#include<stdio.h> activacion de librerias

main() inicio del programa

{

int i=0,j=0,lt,c,res=0,op=1,nc=0;

do

{

clrscr();

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

{



}

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

{

for(j=1;j<=c;j++) proceso para calcular los numerous primos

{

if(i%j==0)

{

nc=nc+1;

}

} cierre de los ciclos for

if(nc==2)

{

printf("%6d",i); impresion de i

Inicio del programa e proceso de

impresión del borde en el programa

Impresión de datos


} cierre

nc=0; inicia en 0

c=c+1; aumento de 1

}

gotoxy(2,23),printf("REPETIR 1 Y 0 PARA SALIR : ");scanf("%d",&op)lee e imprime

}

while(op==1); reconoce la opción

getch(); pausa

} finaliza el programa

3.- Corrido de programa

4.-Analisis del Programa:

Este programa genera }un numero primo asta el limite que nostros ingresemos.

Programa 18 Realice un programa que me permita generar la siguiente serie de datos: como numerador la

serie de los impares y como denominador la factorial.

2.-Codificado:

#include<stdio.h> activacion de librerias

#include<conio.h>

void main()

{

int i,l,a,b,c,op; inicio del programa y declaracion de variables

float f;

do

{

clrscr();

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

{


gotoxy(i,1);printf("*"); proceso de impresion de borde

}

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

{




}

gotoxy(35,2);printf("Serie de datos");

gotoxy(15,3);printf("Limite: "); impresion y lectura de datos

scanf("%d",&l);

a=1;

f=1;

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

{

f=f*i;

gotoxy(28,5+i);printf("%8.0f ",f); proceso de calculo de los numeros

gotoxy(15,5+i);printf("%d",a);

a=a+2;

gotoxy(25,5+i);printf("/");

}

gotoxy(15,23);printf("Desea salir 1/0: ");

scanf("%d",&op);

}

while(op==1); reconose la opcion del while

getch();

} pausa y finalisacion del programa.

3.-Corrido d eprograma:

Programa 19 Genere n elementos de la siguiente serie: cualquier factor ingresado desde teclado como

numerador, el denominador números pares.

1. Enunciado:

Genere n elementos de la siguiente serie: cualquier factor ingresado desde teclado como

numerador, el denominador números pares.


2. Codificado:

#include<conio.h> Librerias

#include<stdio.h>

main()

{

int i, lim, nu=0, num=2, col=5, op, fact; inicio del programa y declaracion de

variables

do

{

nu=0; inicio de variables en 0 y 5

num=2;

col=5;

clrscr(); borrado de pantalla

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

{

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

gotoxy(i,24);printf("-");

} impresion del borde en el programa

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

{

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

gotoxy(80,i);printf("+");

}

gotoxy(30,3);printf("Serie 1 Factor y Numeros pares");

gotoxy(3,5);printf("Limite: ");scanf("%d",&lim); lectura en impresion de

datos

gotoxy(3,7);printf("Factor: ");scanf("%d",&fact);

nu=fact;

for(i=1;i<=lim;i++) inicio del for

{ inicio del for

gotoxy(col,9);printf("%d",fact);

fact=fact+nu; proceso

gotoxy(col,10);printf("--");

gotoxy(col,11);printf("%d",num);lectura e impresion de datos

num=num+2; acumulador

col=col+4; contador

}

gotoxy(3,22);printf("Presione 1 para contuniar o 0 para salir impresión y

");scanf("%d",&op); lectura

} fin for

while(op==1); reconocimiento

getch(); pausa

} fin del programa


PROGRAMA N.-21. -Diseñe un programa que me permita generar la

siguiente serie de datos: primos en el numerador e impares en el

denominador.}

CODIFICADO #include<conio.h>

#include<stdio.h>

main()

{

int res,j,i,col,lim,op,cont,den;

do

{

den=-1;

cont=0;

res=1;

col=5;

Las librerías sirven para llamar

a las funciones q se desee.

Es el inicio de la ejecución del

Sirve para declarar variables

Cumple una función que tiene retorno

Las variables están declaradas desde el

número que van a empezar

Limpia pantalla


clrscr();

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

{

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

gotoxy(i,24); printf("+");

}

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

{

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

gotoxy(80,i); printf("+");

}

gotoxy(20,3); printf("**SERIE DE NUMEROS PRIMOS**");

gotoxy(10,5); printf("INGRESE LIMITE==>");

scanf("%d",&lim);

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

{

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

{

res=i%j;

if(res==0)

{

cont=cont+1;

}

}

if(cont==2)

{

gotoxy(col,7); printf("%d",i);

}

den=den+2;

gotoxy(col,8); printf("-");

gotoxy(col,9); printf("%d",den);

Utilizamos el ciclo for para diseñar el margen de la

pantalla en donde señalamos el numero en el que

empieza y hasta que numero va a llegar, ubicamos

coordenadas e imprimimos en este caso asteriscos.

Indica si es impar o no

Imprime resultado

Operación del denominador

Imprime línea

Imprime

Sirve para ir

Indica que el residuo debe ser 0 para que se cumpla la

Operación para obtener el

Para ingresar hasta que numero va a llegar


col=col+5;

}

gotoxy(10,20); printf("PRESIONE 1 SI DESEA REPETIR EL PROCESO CASI CONTRARIO 0==>");

scanf("%d",&op);

}

while(op==1);

getch();

}

ANALISIS El primer ciclo lleva la cuenta de los números de 1 a lim de uno por uno en la variable c, luego se inicia un ciclo de 1 a i en la variable j. Este ciclo se hará n veces porque está dentro de el primer ciclo, en la variable res se guarda el residuo de dividir i / j , si el residuo es cero, se incremento al contador, si al terminarse el segundo ciclo el contador es igual a 2, significa que el número es primo y lo imprime, y eldenominador solo le va sumando 2 al numero que ingrese el usuario

PROGRAMA N.-22.-diseñe un programa que me permita generar la

siguiente serie de datos: como numerador los números impares y

como denominador la serie fibonasi.

CODIFICADO:

#include<conio.h>

#include<stdio.h>

main()

{

int i,lim,col,a,b,c,fibo,op,num

do

{

fibo=0;

a=1;






Declaramos desde que numero van a

empezar las variables

Se suma a col 5 para la posición

Cierra el ciclo do while

Espera que presione cualquier

otra tecla para salir


b=0;

col=5;

num=-1;

clrscr();

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

{

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


}

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

{

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


}

gotoxy(10,3); printf("**SERIE DE DATOS**");

gotoxy(10,5); printf("INGRESE EL LIMITE==>");

scanf("%d",&lim);

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

{

num=num+2;

gotoxy(col,7); printf("%d",num);

c=a+b;

a=b;

b=c;

fibo=c;

gotoxy(col,9); printf("%d",fibo);

gotoxy(col,8); printf("-");

col=col+5;

}

gotoxy(10,20);

printf("PRESIONE 1 SI DESEA REPETIR EL PROCESO CASO CONTRARIO 0==>");

scanf("%d",&op);

Declaramos que va a empezar desde la columna 5

Declaramos desde que numero va a empezar la

Limpia

Utilizamos el ciclo for para diseñar el margen de la

pantalla en donde señalamos el numero en el que

empieza y hasta que numero va a llegar, ubicamos

coordenadas e imprimimos en este caso asteriscos.

Empezamos a escribir lo que

deseamos que aparezca en la

Guarda la variable indicada

Señalamos hasta el número que se va a

Sumamos al número que ingrese como num el 2 para obtener números

Imprime el

Relizamos la operación, indicamos que a=b;

que b=c; para que se relize correctamente el

proceso, y al final decimos que fibo=c

Imprime el

Imprime la línea que separa al numerador del

Sumamos a col 5 para que vaya cambiando de


}

while(op==1);

getch();

}

ANALISIS En este programa se va smando a col el umero 5 para que todos a fraciones esten en su posici{on correcta adema{as se utiliza un iclo do while para que se repita el proceso tanta veces quiera el usuario.

CORRIDO

PROGRAMA N.-23.- 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.

CODIFICACION:

#include<conio.h>

#include<stdio.h>

#include<stdlib.h>

void borde()

{

int i;

Final del ciclo do

Espera que se presione cualquier otra tecla

para finalizar



Función específicamente para el borde

Variable para el margen de pantalla.


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

{



}

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

{



}

}

void main()

{

int i,suma,a,b,resta,multi,op;

float divi;

do

{

clrscr();

borde();

gotoxy(25,3); printf("MENU DE OPCIONES***OPERACIONES MATEMATICAS");

gotoxy(10,5); printf("1.-SUMA");

gotoxy(10,7); printf("2.-RESTA");

gotoxy(10,9); printf("3.-MULTIPLICACION");

gotoxy(10,11); printf("4.-DIVISION");

gotoxy(10,13); printf("5.-SALIR");

gotoxy(10,15); printf("QUE OPCION DESEA==>");

scanf("%d",&op);

switch(op)

{

case 1:

clrscr();

borde();

Ciclo for para señalar de que numero a que numero va a ir.

Utilizamos el ciclo for para diseñar el

margen de la pantalla en donde

señalamos el numero en el que empieza

y hasta que numero va a llegar,

ubicamos coordenadas e imprimimos en

Limpia la pantalla



Variable para trabajar con decimales

Llama al borde sirve para no volver a repetir el proceso

de este.


Proceso del menú de

opciones

Variable selectiva sirve para elegir una de las funciones

Para señalar el primer proceso

Limpia pantalla

Llama al borde



gotoxy(10,5); printf("INGRESE EL PRIMER VALOR==>"); scanf("%d",&a);

gotoxy(10,7); printf("INGRESE EL SEGUNDO VALOR==>"); scanf("%d",&b);

suma=a+b;

gotoxy(10,9); printf("EL RESULTADO ES==>%d",suma);

break;

case 2:

clrscr();

borde();




if(a>b) Sentencia selectiva para validar datos

{

resta=a-b;

gotoxy(10,9); printf("EL RESULTADO ES==>%d",resta);

}

else

{

gotoxy(10,11); printf("ERROR");

}

break;

case 3:

clrscr();

borde();

gotoxy(20,3); printf("3.-MULTIPLICAION");



multi=a*b; Operación

gotoxy(10,9); printf("EL RESULTADO ES==>%d", multi); Imprime resultado

break;

Cierra primer proceso

Imprime resultado

Se realiza la operación

Segunda opción

Limpia pantalla

Llama al borde

Imprime resultado

Se realiza la operación

Caso contrario

Imprime mensaje en caso de no cumplir con la validación

Cierra segundo proceso

Abre tercera opción

Limpia pantalla

Llama al borde

Cierra tercera opción

Abre cuarta opción


case 4:

clrscr();

borde();




if(a>b)

{

divi=a/b;

gotoxy(10,9); printf("EL RESULTADO ES==>%2.2f", divi);

}

else

{

gotoxy(10,9); printf("ERROR");

}

break;

case 5:

exit(0);

break;

}

gotoxy(10,20);

printf("PRESIONE 1 PARA REPETIR EL PROGRAMA CASO CONTRARIO 0==>");

scanf("%d",&op);

}

-while(op==1);

getch();

}

ANALISIS En ese programa se utiliza un menu de opciones para indicar las diferente alternativas que hay y se un sentencia selectiva llamada switch que sirve para que escoja no de lo procesos que se debe realizar, se utiliza el ciclo do while para repetir el proceso tantas veces quiera el usuario.

Llama al borde

Limpia pantalla

Para validar datos

Operación

Imprime resultado

Caso contrario

Imprime mensaje en caso de no cumplir con la validación

Cierra cuarta opción

Abre quinta opción

Para señalar que debe salir

Cierra quinta opción

Cierra ciclo switch

Cierra ciclo do while

Espera que se presione cualquier otra tecla para

finalizar


CORRID


PROGRAMA N.24.- Diseñe un programa con un menú de opciones que me

permita calcular las áreas y perímetros de las 4 figuras básicas:

circulo, cuadrado, triangulo, rectángulo.

CODIFICACION:

#include<conio.h>

#include<stdio.h>

#include<stdlib.h>

void borde()

{

int i;

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

{



}

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

{



}

}

void main()

{

int ar,per,op,c,d,r,h,a,resultado,b;

float pi=0.00,perimetro=0.00,area=0.00;

do

{

clrscr();

borde();

pi=3.141592654;



Función específicamente para el

borde

Declaración de variable para el borde

Utilizamos el ciclo for para diseñar el

margen de la pantalla en donde

señalamos el numero en el que empieza

y hasta que numero va a llegar,

ubicamos coordenadas e imprimimos en

Para trabajar con variables que tengan

decimales


Limpia

Lama

Indicamos el valor de



gotoxy(20,3); printf("MENU DE OPCIONES *** FIGURAS GEOMETRICAS");

gotoxy(10,5); printf("1.-AREA Y PERIMETRO DEL CUADRADO");

gotoxy(10,7); printf("2.-AREA Y PERIMETRO DEL RECTANGULO");

gotoxy(10,9); printf("3.-AREA Y PERIMETRO DEL CIRLCULO");

gotoxy(10,11); printf("4.-AREA Y PERIMETRO DEL TRIANGULO");

gotoxy(10,13); printf("5.-SALIR");

gotoxy(10,15); printf("INGRESE LA OPCION==>");

scanf("%d",&op);

switch(op)

{

case 1:

clrscr();

borde();

gotoxy(20,3); printf("1.-AREA Y PERIMETRO DEL CUADRADO");

gotoxy(10,5); printf("***AREA***");

gotoxy(10,7); printf("INGRESE EL VALOR==>"); scanf("%d",&a);

ar=a*a;

per=4*a;

gotoxy(10,9); printf("EL AREA ES==>%d",ar);

gotoxy(10,11); printf("***PERIMETRO***");

gotoxy(10,13); printf("EL PERIMETRO ES==>%d",per);

break;

case 2:

clrscr();

borde();

gotoxy(20,3); printf("2.-AREA Y PERIMETRO DEL RECTANGULO");


gotoxy(10,7); printf("INGRESE LA BASE==>"); scanf("%d",&b);

gotoxy(10,9); printf("INGRES LA ALTURA==>"); scanf("%d",&a);

ar=b*a;

per=2*(b+a);

Proceso del menú de

opciones

Variable selectiva sirve para elegir una de las funciones

Para señalar el primer proceso

Limpia pantalla

Llama al borde

Se realizan las operaciones

Imprime resultado

Cierra primer proceso

Segunda opción

Limpia pantalla

Llama al borde

Se realizan las operaciones





break;

case 3:

clrscr();

borde();

gotoxy(20,3); printf("3.-AREA Y PERIMETRO DEL CIRCULO");


gotoxy(10,7); printf("INGRESE EL VALOR==>"); scanf("%d",&r);

area=pi*r*r;

gotoxy(10,9); printf("EL AREA ES==>%2.2f",area);


gotoxy(10,13); printf("INGRESE EL VALOR==>"); scanf("%d",&d);

perimetro=pi*d;

gotoxy(10,15); printf("EL PERIMETRO ES==>%2.2f",perimetro);

break;

case 4:

clrscr();

borde();

gotoxy(20,3); printf("4.-AREA Y PERIMETRO DEL TRIANGULO");


gotoxy(10,7); printf("INGRESE LA BASE==>"); scanf("%d",&b);

gotoxy(10,9); printf("INGRESE LA ALTURA==>"); scanf("%d",&h);

ar=(b*h)/2;



gotoxy(10,15); printf("INGRESE TERCER VALOR==>"); scanf("%d",&c);

per=h+b+c;

Imprime resultado

Limpia pantalla

Tercera opción

Cierra segunda opción

Llama al borde

Operación

Operación

Imprime resultado

Imprime resultado

Cierra tercera opción

Cuarta opción

Limpia pantalla

Llama al borde

Operación

Imprime resultado

Operación

Imprime resultado



break;

case 5:

exit(0);

break;

}

gotoxy(10,23); printf("PARA REPETIR EL PROCESO PRESIONE 1 CASO CONTRARIO 0==>");

scanf("%d",&op);

}

while(op==1);

getch();

}

ANALISIS Este programa utiliza un menú de opciones de las áreas y perímetros de las figuras geométricas,

utilizamos una sentencia selectiva switch para que seleccione el proceso que debe realizar, al inicio

se declara a la variable pi con s valor ara que se pueda ejecutar correctamente en el momento de

realizar la operación, se utiliza un ciclo do while para que el proceso se repita tantas veces quiera el

usuario

CORRIDO

Cierra cuarta opción

Quinta opción

Para indicar que debe salir

Cierra quinta opción

Cierra ciclo switch

Cierra ciclo do while

Espera que se presione cualquier otra tecla para

finalizar


Programa 25

Diseñe un programa a través de un menú de opciones que me permita calcular las 6

operaciones básicas con sus respectivas validaciones. Estas son suma, resta, multiplicación,

división, potenciación y radicación.

ANÁLISIS

Suma h=b + a; Resta H = b – a; Multiplicación h = a*b

H=2+5 b>a h= 5-2 h= 3*4

H=7 h= 3 h= 12

División h=b/a; Potenciación h= Radicación h=

b>a h=6/3 h= h=

h=2 h=8 h=8

CODIFICADO:

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

void borde()

{

int i;

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

{



}

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

{



}

}

void main ()

{

int op,i,a,p,h,j,w,x,y,z,b;

j=1;

ACTIVACIÓN DE LIBRERÍAS Gestión de memoria dinámica, control de procesos y otras. Activa la cadena de caracteres. Inicializa el programa.

Inicializa la función del borde.

Declaración de variables.

Inicialización del for.

Inicialización del programa.

Declaración de variables.

Inicializamos; j=1;

Limpiar la pantalla

Impresión del borde


clrscr();

borde();

gotoxy(35,1);printf("EJERCICIO N.-");

gotoxy(20,3);printf("**MENU DE OPERACIONES BASICAS**");

gotoxy(25,6);printf("1.- SUMA ");

gotoxy(25,7);printf("2.- RESTA");

gotoxy(25,8);printf("3.- MULTIPLICACION");

gotoxy(25,9);printf("4.- DIVICION");

gotoxy(25,10);printf("5.- POTENCIACION");

gotoxy(25,10);printf("6.- RADICACION ");

gotoxy(25,10);printf("7.- SALIR");

gotoxy(25,13);printf("INGRESE UNA OPCION : ");scanf("%d",&op);

switch(op)

{

case 1:

clrscr();

borde();

gotoxy(35,2);printf("***SUMA***");

gotoxy(25,6);printf("INGRESE EL PRIMER VALOR : ");scanf("%d",&b);

gotoxy(25,7);printf("INGRESE EL SEGUNDO VALOR: ");scanf("%d",&a);

h=b+a;

gotoxy(48,8);printf(" ---");

gotoxy(38,9);printf(" RESPUESTA : %d",h);

break;

case 2 :

clrscr();

borde();

gotoxy(35,2);printf("***RESTA***");

gotoxy(25,6);printf("INGRESE EL PRIMER VALOR : ");scanf("%f",&b);

gotoxy(25,7);printf("INGRESE EL SEGUNDO VALOR: ");scanf("%f",&a);

h=b-a;


gotoxy(38,9);printf(" RESPUESTA : %f",h);

break;

case 3 :

clrscr();

borde();

gotoxy(35,2);printf("***MULTIPLICACION***");



h=b*a;

IMPRESIÓN DE

DATOS

Impresión y lectura

Inicialización del switch

Inicialización de switch

Inicializació

n limpiar la

pantalla

impresión

del borde

impresión y

proceso de

suma e

Inicializació

n del case2

limpiar la

pantalla

proceso de

la resta e

impresión

Proceso e

impresión de la

multiplicación




break;

case 4 :

clrscr();

borde();

gotoxy(35,2);printf("***DIVISION***");

do{

gotoxy(25,6);printf("INGRESE EL PRIMER VALOR : ");

gotoxy(25,7);printf("INGRESE EL SEGUNDO VALOR: ");



}while(a>b);

e=b/a;


gotoxy(38,9);printf(" RESPUESTA : %f",e);

break;

case 5 :

clrscr();

borde();

gotoxy(35,2);printf("***POTENCIACION***");

gotoxy(25,6);printf("INGRESE EL VALOR : ");scanf("%f",&b);

gotoxy(25,7);printf("INGRESE LA POTENCIA: ");scanf("%f",&a);

h=pow(b,a);



break;

case 6 :

clrscr();

borde();

gotoxy(35,2);printf("***RADICACION***");


h=sqrt(b);



break;

case 7 : /*inicializa el case 7

exit(0); /*sale del programa

break; /* Finaliza el switch

default: /*caso contrario

clrscr(); /* limpia la pantalla

Finaliza el

Inicializa el

case 4 lectura

proceso e

impresión de la

división

validación de

los valores a>b

Inicializa el

case 5 lectura

proceso e

impresión de

la

Inicializa el

case 6 lectura

proceso e

impresión de la

potenciación


gotoxy(38,12);printf("***ERROR***"); /* imprime error

} /*cierra la llaves de switch

gotoxy(28,23);printf("PRESIONE (1) PARA VOLVER AL MENU: ");scanf("%d",&mk);

}while(mk==1); /*imprime y cierra el while valida

la opción/*

getch(); /* hace una pausa

}

}

getch();

}

CORRIDO

Programa 26

Diseñe un programa que me permita realizar las conversiones básicas: metros, kilómetros,

decámetros, hectómetros.


Analisis:

KM DM; M; Cm; Mm.

DM km; M; Cm; mm

M km; Dm; Cm; mm

Cm km; Dm; M; mm

Mm km; Dm; M; Cm

Codificación:

#include<conio.h>

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

#include<math.h>

void borde()

{

int i;

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

{



}

for(i=1;i<=24;i++) /*for inicializa en 1 hasta 24

{ /*abrimos la llave del for

gotoxy(1,i);printf("*"); /*impresión de * en la columna 1 fila i++

gotoxy(80,i);printf("*"); /*impresión de * en la columna 80 fila i++

}

}

void main () /*inicialización del programa

{ /* llaves de inicio de programa

int op,i,p,j,w,x,y,z,mk;

float a,e,b,h,d,cm,mm,m,k,dm;

j=1; /* inicializacion de j en 1

do /*inicialisa el do

{

clrscr(); /*borrado de pantalla

borde(); /*llamado a la función borde

textcolor(BLUE); /* color azul del texto

gotoxy(35,1);printf("EJERCICIO N.-");

gotoxy(25,3);printf("**MENU DE CONVERCIONES BASICAS**");

gotoxy(25,6);printf(" EL VALOR A INGRESAR ES EN:");

gotoxy(25,7);printf("1.- KILOMETROS");

gotoxy(25,8);printf("2.- DECAMETROS ");

Activación de librerías y

comienzo del programa

Realización del Borde con

función


Impresión del

menú


gotoxy(25,9);printf("3.- METROS");

gotoxy(25,10);printf("4.- CENTIMETROS");

gotoxy(25,11);printf("5.- MILIMETROS ");


gotoxy(25,13);printf("INGRESE UNA OPCION : ");scanf("%d",&op); /*lectura de opción

switch(op) /* inicio del switch con la opción escogida

{ /* llaves de inicio de switch

case 1:

clrscr();

borde();

gotoxy(28,2);printf("***VALOR EN KILOMETROS***");


d=b/0.01;

m=b/0.001;

cm=b/0.00001;

mm=b/0.000001;

gotoxy(30,5);printf(" KM : %f",b);

gotoxy(30,6);printf(" DM : %f",d);

gotoxy(30,7);printf(" M : %f",m);

gotoxy(30,8);printf(" cm : %f",cm);

gotoxy(30,9);printf(" mm : %f",mm);

break;

case 2 :

clrscr();

borde();

gotoxy(28,2);printf("***VALOR EN DECAMETROS***");


k=b*100;

m=b/0.001;

cm=b/0.00001;

mm=b/0.000001;

gotoxy(30,5);printf(" KM : %f",k);

gotoxy(30,6);printf(" DM : %f",b);




break;

case 3 :

clrscr();

borde();

gotoxy(28,2);printf("***VALOR EN METROS***");


k=b*0.001;

Inicio de case 1

Borrado de

pantalla función

de borde

impresión del

titulo lectura del

valor en km

proceso para

calcular las demas

Inicialización de case

borrado de pantalla

función borde

impresión del título

lectura del valor en DC

proceso para la

transformación.

Impresión de resultados.

Inicialización de

case 3 borrado

de pantalla

función borde

impresión del

título lectura

del valor en M

proceso para la

transformación.

Impresión de


dm=b*0.1;

cm=b*100;

mm=b*1000;


gotoxy(30,6);printf(" DM : %f",dm);

gotoxy(30,7);printf(" M : %f",b);



break;

case 4 :

clrscr();

borde();

gotoxy(28,2);printf("***VALOR EN CENTIMETROS***");


k=b*0.0001;

dm=b*0.01;

m=b/100;

mm=b*10;




gotoxy(30,8);printf(" cm : %f",b);


break;

case 5 :

clrscr();

borde();

gotoxy(28,2);printf("***VALOR EN CENTIMETROS***");


k=b*0.00001;

dm=b*0.001;

m=b/1000;

mm=b*100;




gotoxy(30,8);printf(" cm : %f",mm);

gotoxy(30,9);printf(" mm : %f",b);

break;

case 6 : // inicia el case 6

Inicialización de

case 3 borrado

de pantalla

función borde

impresión del

título lectura

proceso para la

transformación.

Impresión de

resultados.

Inicialización de

case 5 borrado

de pantalla

función borde

impresión del

título lectura

del valor en mm

proceso para la

transformación.

Impresión de

resultados


exit(0); // sale del programa

break; // finalize el switch

default: // caso contrario

clrscr(); // borrado de pantalla

gotoxy(38,12);printf("***ERROR***"); // imprime error

}

gotoxy(28,23);printf("PRESIONE (1) PARA VOLVER AL MENU: ");scanf("%d",&mk);

}while(mk==1); // lectura de mk en while

getch(); //pausa

} // llave que finaliza el programa

CORRIDO

Programa 27 Diseñe un programa que me permita generar el siguiente menú de opciones de la siguiente

comprobación de los siguientes números :

1. Números Pares

2. Números Impares

3. Números primos

4. Salir

Análisis :

Números pares =0+2=2+2=4+2=6……..N

Números impares=1+2=3+2=5+2=7..….N

Números primos= 1,3,5,7…….n

Codificación:

#include<conio.h>

#include<stdio.h> Activación de librerías


#include<stdlib.h>

int limite,op,i,resulpar,n,numpar,ni,numimpar,r,cont,np; //declaración de variables

void borde()

{

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

{



}

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

{



}

}

void numerospar (int numpar1) // function para numerous par

{ //inicio

resulpar=n%2; // coje el resioduo de n/2

if(resulpar==0) // si en residuo es 0

{

gotoxy(29,6);printf("EL NUMERO %d ES PAR",n); //imprime par

}

else

{

gotoxy(28,6);printf("EL NUMERO %d ES IMPAR",n); //caso contrario imprime impar

}

}

void numerosimpar (int numimpar1) // función de numeros impares

{ // inicio

resulpar=n%2; // residuo =1

if(resulpar==1)

{

gotoxy(29,6);printf("EL NUMERO %d ES IMPAR",n);//imprime es par

}

else

{

gotoxy(28,6);printf("EL NUMERO %d ES PAR",n); //caso contrario es impar

} //cierre del ese

} // fin de la funcion

void numpri (int np1) //funcion para numero primo

{ // inicio

cont=0; // cont inicializa en 0

for(i=1;i<=n;i++) // inicia en 1 hasta n si suma i++

función del borde

inicio del for con incremento i++; hasta 80

impresión de *

Inicio de for con incremento i++; hasta 24

Impresión de *


{

r=n%i;

if(r==0) //si el residuo es 0

{

cont=cont+1; // contador vale 1 y v air sumand 1+1

}

}

if(cont==2) // contador vale 2

{

gotoxy(30,5);printf("EL NUMERO %d ES PRIMO",n);//imprime es primo

}

else //caso contrario

{

gotoxy(30,5);printf("EL NUMERO %d ES PRIMO",n); //imprime no es primo

}

}

void main() inicia el programa

{

do{

clrscr();

borde();

gotoxy(28,2);printf("MENU DE VERIFICACION");

gotoxy(20,4);printf("1.- VERIFICACION DE NUMEROS PARES");

gotoxy(20,5);printf("2.- VERIFICACION DE NUMEROS INPARES");

gotoxy(20,6);printf("3.- VERIFICACION DE NUMEROS PRIMOS");


gotoxy(20,8);printf("ELIJA UNA OPCIONN : ");scanf("%d",&op); //lectura de op

switch(op)

{

case 1 :

clrscr();

borde();

gotoxy(28,2);printf("VERIFICACION DE PARES");

gotoxy(28,4);printf("INGRESE UN NUMERO : ");scanf("%d",&n);

numerospar(numpar);

break;

case 2 :

clrscr();

borde();

gotoxy(28,2);printf("VERIFICACION DE IMPARES");


numerosimpar(numimpar);

Impresión del

menu

Case 1 borrado de pantalla

Función borde impresión

del título lectura de n

llamado a la función.






break;

case 3 :

clrscr();

borde();

gotoxy(28,2);printf("VERIFICACION DE PRIMOS");


numpri(np);

break;

case 4:



default : // caso contrario

clrscr();

gotoxy(30,12);printf("***ERROR***"); // imprime error

gotoxy(20,21);("PRESIONE (1) PARA VOLVER AL MENU");

break;

}

gotoxy(20,21);("PRESIONE (1) PARA VOLVER AL MENU");

scanf("%d",&op);

}while(op==1);

getch();

}

CORRIDO:

Programa 28 Diseñe un programa que me permita realizar un borde utilizaciones funciones.

Analisis-:

Utilizacion de for en:

filas hasta 24

Columnas hasta 80






Codificado:

#include<conio.h>

#include<stdio.h>

int i; //declaración de variables

void borde()

{

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

{



}

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

{



}

}

Void main () //inicio del programa

{

clrscr();

borde(); // función borde

printf(“borbe”); // impresión borde

}

getch();

CORRIDO:

Activación de librerías

función del borde

inicio del for con incremento i++; hasta 80

impresión de *

Inicio de for con incremento i++; hasta 24

Impresión de *


Programa 29 Diseñe un programa utilizando funciones que me permita generar n números naturales

Análisis:

utilización de un ciclo for

con un limite n

en una sola función

con dos variables i n

Codificación:

#include<conio.h>

#include<stdio.h>

int limite,op,i,fila,col; // declaración de variables

void borde()

{

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

{



}

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

{



}

}

void numeros (int limite1)

{

col=20; //columna inicia en 20

fila=5; // fila inicia en 5

for(i=1;i<=limite1;i++) inicia 1 hasta n I aumenta i++

{

gotoxy(col,fila);printf("%d",i); //imprime i

fila=fila+1; //fila incrementa +1

if(fila==18) //si la fila llega a 18 se aumenta 10

{

Activación de

Función borde

Función números

naturales


col=col+10;

fila=7;

}

}

}

void main ()

{

clrscr();

borde();

gotoxy(20,2);printf("SERIE DE NUMEROS");

gotoxy(15,4);printf("INGRESE UN LIMITE : ");scanf("%d",&limite);

numeros (limite);

getch();

}

CORRIDO:

Impresión del

título función

limite


CORRIDO:

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

Analisis: Se utilizara funciones, condiciones, ademas de eso se imprimira el borde de pantalla.

Las condiciones serán:

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%

´para los tres vendedores

CoDIFIcado:

#include<stdio.h>

Activación de

librerias


#include<conio.h>

#include<stdlib.h>

int i,op,op1,cont1,q; // declaracion de variables enteras

float tv,venta,val,contv; // declaracion de variables flotantes

void borde()

{

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

{



}

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

{

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


}

}

void v1(int ven) // inicia función int ven

{ //llave de inicio de la función

if(venta<8500) //primera condición

{ no realiza nada con esta condición

}

Else //caso contrario

{ // llave inicio del else

if(venta>=8500 && venta<=13500) // proceso un nuevo if

{ // llave de inicio del if

tv=venta*0.03; //proceso

} // termina el if

Else // caso contrarion

{ //nueva proceso

if(venta>13500 && venta<=18000)//condicion

{ // llave de inicio


} //termina if

else //caso contrario

{ //llave de inicio


}

} cierre de los 2 if

Y de la funcion

}

}

void main()

Inicio del borde

Inicia el for hasta 80 con un incremento de i++

Impresión de *

Impresión de *

Inicia el segundo for hasta 24 con el incremento

de i++

Imprime *


{

q=0;

do

{

q=q+1;

clrscr();

borde();

gotoxy(30,3);printf("COMISIONES POR VENTAS DE VEHICULOS");

gotoxy(10,5);printf("1.Vendedor 1");



gotoxy(10,8);printf("4.Total de ventas");

gotoxy(10,9);printf("5.Salir");

gotoxy(10,10);printf("Elija opcion: ");scanf("%d",&op);

switch(op)

{

ytcont1=0;

contv=0;

val=0;

do

{

case 1: // inicio de case 1

clrscr(); // borrado de pantall

borde(); //llama la funcion borde

cont1=cont1+1; //cont va ir sumando cada vez que se repita

gotoxy(10,5);printf("Vendedor 1: ");scanf("%f",&venta); //impresión y lectura de

datos

v1(venta); // llama la funcion venta

contv=contv+tv; //va ir incrementado cada vez que se repita

val=val+venta; // va ir incrementado cada vez que se repita

gotoxy(15,20);printf("Desea insertar otra venta 1/0: ");scanf("%d",&op1);

}while(op1==1); // evalúa la opción escogida

break; // filaliza el switch

do

{

case 2: // inicio de case 2

clrscr(); // borrado de pantalla

borde(); // llamado a la funcion bnorde

cont1=cont1+1; //va ir incrementado cada vez que se repita

gotoxy(10,5);printf("Vendedor 2: ");scanf("%f",&venta);

v1(venta); //va ir incrementado cada vez que se repita

Inico del programa, declaracion de q=0,

borrado de pantalla, impresión del

borde

Impresión

de datos

Inicio del switch

Iniciación de variables en 0

Inico de un ciclo do


contv=contv+tv; //va ir incrementado cada vez que se repita

val=val+venta; //va ir incrementado cada vez que se repita


}while(op1==1); // evalúa la opción escogida

break; // filaliza el switch

do

{

case 3:

clrscr();

borde();

cont1=cont1+1;

gotoxy(10,5);printf("Vendedor 3: ");scanf("%f",&venta);

v1(venta);

contv=contv+tv;

val=val+venta;


}while(op1==1);

break;

case 4:

clrscr();

borde();

gotoxy(15,6);printf("Total ventas: %d",cont1);

gotoxy(15,7);printf("Total comicion: %2.2f",contv);

gotoxy(15,8);printf("Total valor: %2.0f",val);

break;

case 5: //case 5



}


}while(op==1); // evalua la opcion escojida

getch();

}

Corrido:

Case 3

limpia

pantalla

llama

borde

Contadore

s

Impresión de

resultados


Programa 32 Diseñe un programa permita obtener el valor a pagar por concepto consumo de agua potable

según el siguiente condicionamiento.

Se ingresa desde teclado el nombre del abonado y las lecutras del medidor del mes antesior y

del mes actual, considerando siempre que la lecutura actual no puede ser menor que la anterio,

la diferenciaentre las dos lecturas me permite obtener el consumo actual las mismas que tiene

el siguiente condicionamiento

Si el consumo es ≤ 30 litros de agua, se le factura el valor minimo que son Usd. 6,00

Si el consumo es > 30 y ≤ que 200 se cobra, 1,50 centavos cada litro de agua

Si el cosnumo es > 200 litros se cobra 2,75 cada litro

A este importe total obtenido se le añade los impuestos de ley

5% Basurero

%5 IECE

3% Municipio

Obtenga el costo total de la factura

El programa debe funcionar para n usuarios al final se visualiza el número total de

usuarios recaudados y el valor total recaudado.

CODIFICADO: #include<conio.h>

#include<stdio.h>

#include<stdlib.h>

int op,i,tr=0,valor,cuenta,tao,n=0,consumo,l1,l2,consumo1,consumo2,muni,bas,iece;//

declaracion de variables

char nom; // declaracion de caracteres

void borde()

{

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

{



}

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

{



}

}

void decis (int consumo2)

{

if(consumo2<30)

Activación de librerias

Función borde


{

valor=6;

}

if(consumo2>30 && consumo2<=200)

{

valor=(consumo2*1.50)+consumo2;

}

if(consumo2>200)

{

valor=(consumo2*2.75)+consumo2;

}

}

void main() // inicio del programa

{

do

{

clrscr();

borde();

gotoxy(30,2);printf("**EMPRESA MUNICIPAL DE AGUA POTABLE**");

n=n+1; // va ir sumando 1 +1

gotoxy(18,4);printf("%d",n); // lecura de datos

gotoxy(20,4);printf("INGRESE SU NOMBRE : ");scanf("%s",&nom);

gotoxy(3,5);printf("lectura de consumo del mes de septimbre : ");scanf("%d",&consumo1);

do{

gotoxy(3,6);printf("lectura de consumo del mes de octubre ");

gotoxy(3,6);printf("lectura de consumo del mes de octubre : "); scanf("%d",&consumo2);

}while(consumo2<consumo1);

decis (consumo1); // llamado a la función concumo

gotoxy(5,10);printf("valor consumo es de: %d",valor);// impresión de valores

bas=valor*0.05;

iece=valor*0.05; proceso

muni=valor*0.03;

tao=valor+bas+iece+muni;

gotoxy(5,11);printf("valor basura : %d",bas);

gotoxy(5,12);printf("valor IECE : %d",iece);

gotoxy(5,13);printf("valor MUNICIPIO: %d",muni);

gotoxy(5,14);printf("valor TO A PAG : %d",tao);

tr=tao++ impresión de datos

gotoxy(50,20);printf("N USUARIOS : %d",n);

gotoxy(50,21);printf("total recaudado : %d ",tr);

gotoxy(20,22);printf("presione 1 para continuar: ");scanf("%d",&op);

}while(op==1);

getch();

Inicio de la función

llave de inicio de la función

Condición c<3 Valor va ser 6

Condición c>30yc<=200

Proceso

Condición c>200

proceso

Inicio de ciclo do

Borrado de pantalla

Llamado a la función borde

Impresió

n de


}

CORRIDO:


ELEMENTO 3

http://www.youtube.com/watch?v=sMy7EbJlhp4

http://www.youtube.com/watch?v=sMy7EbJlhp4


ELEMENTO 4

Funciones vectores matrices


Inicio de la función borde

PROGRAMA 33

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

2. ANALISIS

Para este programa se necesitan varias funciones de condición if para hacer la comparación

y así poder imprimir los números en forma ascendente y para validar los números también

otros if para que el número ingresado este el rango que se pedía en el programa

3. DOCUMENTACION #include<stdio.h>

#include<conio.h>

int i,a,b,c,op;

void borde()

{

for(i=1;i<=80;i++) inicio del for

{

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

gotoxy(i,24);printf("±");

}

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

{



}

}

void numero()

{

do

{


gotoxy(15,4);printf("Numero 1; ");scanf("%d",&a);

}

while(a>64 || a<4);

do

{


gotoxy(15,5);printf("Numero 2: ");scanf("%d",&b);

}

while(b>64 || b<4);

LIBRERIA


Impresión del margen

Inicio de la función void main

Inicio del do

Ingreso el primer numero

Si ese numero cumple con la

condición empleada pide el

siguiente numero

Inicio del do

Ingreso el segundo numero

Si ese numero cumple con la

condición empleada pide el

siguiente numero


do

{


gotoxy(15,6);printf("Numero 3: ");scanf("%d",&c);

}while(c>64 || c<4);

}

void orden()

{

if(a<=b && a<=c)

{

if(b<=c)

{

gotoxy(15,8);printf("%d %d %d",a,b,c);

}

if(c<=b)

{

gotoxy(15,8);printf("%d %d %d",a,b,c);

}

}

if(b<=a && b<=c)

{

if(a<=c)

{

gotoxy(15,8);printf("%d %d %d",b,a,c);

}

if(c<=a)

{

gotoxy(15,8);printf("%d %d %d",b,c,a);

}

}

if(c<=a && c<=b)

{

if(a<=b)

{

gotoxy(15,8);printf("%d %d %d",c,a,b);

}

if(b<=a)

{

gotoxy(15,8);printf("%d %d %d",c,b,a);

}

}

gotoxy(15,7);printf("El orden es:");

}

Inicio del do

Ingreso el tercer numero

Inicio de la función void

Proceso para presentar

los números

ingresados en forma

ordenada

ascendentemente.


void main()

{

do

{

clrscr();

borde();

numero();

orden();


}

while(op==1);

getch();

}

4. CORRIDO DEL PROGRAMA

Borrar

pantalla Llamar al borde

Llamar a la

función numero Llamar a la función

Fin del programa

Si la opción ingresada por el usuario es igual a 1

el proceso se repetirá

Inicio de la función principal


PROGRAMA 34

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

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

3. DOCUMENTACION #include<stdio.h>

#include<conio.h>

#include<math.h>

int i,r,dos=2,ex=1,ex2=2,s,v,l1,expo2=2,expo3=3,a,b,c,f=9,i,op;

void borde()

{

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

{



}

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

{



}

}

void perfecto(int l)

{

r=pow(dos,ex);

s=pow(dos,ex2);

v=r*(s-1);

gotoxy(7,8);printf("%d",v);

for(i=1;i<=l-1;i+

{

a=pow(dos,expo2);

b=pow(dos,expo3);

expo2=expo2+2;

expo3=expo3+2;

c=a*(b-1);

gotoxy(7,f);printf("%d",c);

LIBRERIA



Impresión del margen

Operaciones para sacar

los números perfectos

Inicio de la función void

perfecto

Operaciones para sacar

los números perfectos

Impresión de los números

perfectos


f=f+1;

}

}//cierre del void

void main()

{

do

{

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

clrscr();

borde();

gotoxy(30,4);printf("SERIE DE NUMEROS PERFECTOS");

gotoxy(5,6);printf("Ingrese un limite: ");scanf("%d",&l1);

perfecto(l1);


gotoxy(4,22);printf("PRESIONE 1 PARA VOLVER AL MENU O 0 PARA SALIR: ");scanf("%d",&op);

}

while(op==1);

getch();

}

4. CORRIDO DEL PROGRAMA

Borrar

Llamar al borde

Impresión del

Ingreso del limite

Llamo a la función perfecto

Si la opción ingresada por el usuario es igual a 1

el proceso se repetirá Fin del

programa


Inicio de la función principal


Programa 35

ENUNCIADO Diseñe un programa utilizando funciones que me permita resolver un sistema de ecuación

de 2° grado.

Análisis.

Partiremos escribiendo la fórmula para tener base de que nomás se va a utilizar.

La fórmula genera dos respuestas: Una con el signo más (+) y otra con el signo menos

(−) antes de la raíz. Solucionar una ecuación de segundo grado se limita, entonces, a

identificar las letras a, b y c y sustituir sus valores en la fórmula.

La fórmula general para resolver una ecuación de segundo grado sirve para resolver

cualquier ecuación de segundo grado, sea completa o incompleta, y obtener buenos

resultados tiene que ver con las técnicas de factorización.

Codificación.

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#include <math.h>

int i,j,op; // declaración de variables globales

void borde()

{

textcolor(BLUE);

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

{

gotoxy(i,1);cprintf("*");

gotoxy(i,24);cprintf("*"); función del borde

}

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

{

gotoxy(1,i);cprintf("*");

gotoxy(80,i);cprintf("*"); // impression de *

Activation de Liberia


} // fin del ciclo for

} // fin de la function borde

void seg () // function para la ecuacion

{ // inicio de la function

float a, b, c;

float x1, x2;

float x1real, x2real; /* complejas */

float x1imag, x2imag; /* Partes imaginarias soluciones complejas */

float discriminante; /* Presentacion */

system ("cls"); /* Borrado de la pantalla */

borde();

gotoxy(10,3);printf("RESOLUCION DE LA ECUACION DE SEGUNDO GRADO\n");

gotoxy(2,4);printf("========================================================

======\n");

gotoxy(10,5);printf("El programa soluciona la ecuación de segundo grado\n");

gotoxy(10,6);printf(" 2 \n");

gotoxy(10,7);printf("ax + bx + c = 0 \n");

/* Petición de datos */

printf("Introduzca los coeficientes:\n");

printf(" Coeficiente a: "); scanf("%f", &a);

printf(" Coeficiente b: "); scanf("%f", &b);

printf(" Coeficiente c: "); scanf("%f", &c);

/* Cálculos y resultados */

discriminante = b*b - 4*a*c; // calculo de discriminate

printf("\n La ecuacion\n");

printf(" %14d\n", 2);

printf(" %12gx + %gx + %g = 0\n", a, b, c); // impresiones

printf(" tiene por soluciones ");

if (discriminante == 0) // sentencia si dis es = a 0


{ // inicio de if

printf(" una raiz real doble\n"); // impresión

x1 = x2 = -b / (2*a); // calculo

printf(" x1 = %.2f\n", x1);

printf(" x2 = %.2f\n", x2); // impresión en pantalla

} // fin de if

else if (discriminante > 0) //si dis es mayor a cero

{ // cálculos

printf(" dos raices reales\n");

x1 = (-b + sqrt(discriminante)) / (2*a);

x2 = (-b - sqrt(discriminante)) / (2*a);

// impresiones

printf("x1 = %.2f\n", x1);

printf("x2 = %.2f\n", x2);

}

Else // caso contrario

{ //impresión en pantalla

printf("dos raíces complejas conjugadas\n");

//cálculos

x1real = x2real = -b / (2*a);

x1imag = sqrt(-discriminante) / (2*a);

x2imag = -sqrt(-discriminante) / (2*a);

// impresiones

printf("x1 = ( %.2f, %.2fi)\n", x1real, x1imag);

printf("x2 = ( %.2f, %.2fi)\n", x2real, x2imag);

} //fin del ese

} // fin de la función

void main () // inicio del programa

{ // llave de inicio

Do //ciclo do

{ // llave de inicio de do


borde (); // funcion borde

seg (); // funcion seg

gotoxy(22,22);printf("desea continuar: ");scanf("%d",&op); // impresión en pantalla y lectura

} while(op==1);

getch(); //pausa

} // fin del programa.

Corrido


Programa 36

ENUNCIADO

Diseñe un programa en C, utilizando funciones que permita:

1.- Obtener la edad de una persona en años, meses y días

2.-Descomponer un número de 4 cifras en todos sus componentes

Análisis: Para calcular el número de años, meses y días que tiene una persona debemos tener

en cuenta que debemos restar del número del año actual el año de nacimiento, y de la misma

forma los meses y los días, si uno no nos alcanza para poder restar, debemos pedir prestado

una unidad, bien sea al mes o al años, dependiendo el orden. Entonces primero ingresamos

por teclado la fecha de nacimiento y la fecha actual, y procedemos a realizar los procesos

mencionados anteriormente. Ahora bien, para descomponer un número de 4 cifras, debemos

primero dividir dicho número ingresado para 1000 y multiplicarlo por 1000,

(um=(num/1000)*1000), realizamos la división con / para tomar solo el número entero y al

multiplicarlo por 1000 podremos encontrar la unidad de millar del número ingresado, y restar

del número ingresado la unidad de millar, (num=num-um), de igual forma será para encontrar

la centena, (c=(num/100)*100), (num=num-c), la decena ,(d=(num/10)*10), (num=num-d), y

la unidad es lo que nos sobra. Y al final solo visualizamos los resultados.

Documentación:

#include<conio.h>

#include<stdio.h>

#include<stdlib.h>

int op, d, m, a, dn, mn, an, a1, dd, mm, aa, mmm, ddd, num, um, c, dec;

void borde()

{

int i;

clrscr();

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

{



}

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

{



}

}

void edad()

{

do

{


Función borde

librerias


gotoxy(11,6);scanf("%d",&dn);

}

while(dn<1 || dn>30);

gotoxy(13,6);printf("/");

do

{


gotoxy(14,6);scanf("%d",&mn);

}

while(mn<1 || mn>12);


gotoxy(17,6);scanf("%d",&an);

gotoxy(5,8);printf("Ingrese la fecha actual dd/mm/aa>> ");

do

{


gotoxy(11,9);scanf("%d",&d);

}

while(d<1 || d>30);


do

{


gotoxy(14,9);scanf("%d",&m);

}

while(m<1 || m>12);


gotoxy(17,9);scanf("%d",&a);

dd=d-dn+30;

if(dd>30)

{

dd=dd-30;

mm=m-mn+12;

}

else

{

mm=m-mn-1+12;

if(mm>12)

{

mm=mm-12;

aa=a-an;

}

else

{

aa=a-an-1;

}}

gotoxy(5,13);printf("Usted tiene %d dias",dd);

gotoxy(5,14);printf("Usted tiene %d meses",mm);

gotoxy(5,15);printf("Usted tiene %d anos",aa);

}

Proceso de calculo del la

edad

Proceso de calculo del la

edad

Condiciones dek proceso

del calculo


void desc()

{

do

{


gotoxy(5,5);printf("Ingrese un numero>> ");scanf("%d",&num);

}

while(num<1000 || num>9999);

um=(num/1000)*1000;

gotoxy(5,7);printf("Unidad de millar>> %d",um);

num=num-um;

c=(num/100)*100;

gotoxy(5,9);printf("Centena>> %d",c);

num=num-c;

dec=(num/10)*10;

gotoxy(5,11);printf("Decena>> %d",dec);

num=num-dec;

gotoxy(5,13);printf("Unidad>> %d",num);

}

void main()

{

do

{

clrscr();

borde();

gotoxy(32,3);printf("<<MENU DE OPCIONES>>");

gotoxy(5,5);printf("1.- Calcule su edad>>");

gotoxy(5,7);printf("2.- Descomponer un numero de 4 cifras>>");

gotoxy(5,9);printf("3.- Salir>>");

do

{


gotoxy(5,11);printf("Que desea realizar>> ");scanf("%d",&op);

}

while(op>3);

switch(op)

{

case 1:

clrscr();

borde();

gotoxy(33,3);printf("<<CALCULE SU EDAD>>");

gotoxy(5,5);printf("Ingrese su fecha de nacimiento dd/mm/aa>> ");

edad();

break;

case 2:

clrscr();

borde();

gotoxy(33,3);printf("<<DESCOMPOSICION DE UN NUMERO>>");

desc();

break;

Imprecion en pantalla de resultados

del calculo de la edad

Imprecion en pantalla

de resultados del

calculo de la edad

Imgreso en pantalla

de resultados del

calculo de la edad


case 3:

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

Corrido:


Programa 37 ENUNCIADO

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

diferentes.

Análisis: 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.

Documentación:

#include<conio.h>

#include<stdio.h>

#include<stdlib.h>

int op;

void borde()

{

int i;

clrscr();

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

{



}

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

{



}

}

void bsim()

{

int i;

clrscr();

gotoxy(1,1);printf("Ú");

gotoxy(80,1);printf("¿");

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

{

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

gotoxy(i,24);printf("Ä");

}

gotoxy(1,24);printf("À");

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

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

{

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

gotoxy(80,i);printf("³");

librerias

Función borde

Función borde


}

}

void bdob()

{

int i;

clrscr();

gotoxy(1,1);printf("É");

gotoxy(80,1);printf("»");

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

{

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


}

gotoxy(1,24);printf("È");

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

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

{

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


}

}

void ep()

{

int i;

clrscr();



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

{

gotoxy(i,3);printf("ù");

gotoxy(i,21);printf("ù");



}



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

{



}

}

void lucho()

{

int i;

clrscr();

gotoxy(1,1);printf("þ");


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

{

Función borde

Función borde


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

gotoxy(i,24);printf("þ");

}



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

{

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

gotoxy(80,i);printf("þ");

}

}

void main()

{

do

{

clrscr();

borde();

gotoxy(30,3);printf("<<ESTILOS DE BORDES>>");

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:

clrscr();

lucho();

gotoxy(30,10);printf("<>>");

Función borde

Función borde

Función borde


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

Corrido:


Programa 38

Diseñe un programa utilizando vectores y funciones que me permita ingresar datos a

un vector y presentarlos en otro vector

ANÁLISIS

Primero ingresamos las librerías que vamos a utilizar en este programa en este caso

son las dos principales la STDIO.H Y LA CONIO.H, después como es un programa

con funciones declaramos la variable que vamos a utilizar globalmente.

Después ingresamos una función con el nombre de borde para que nuestro

programa se visualice con un borde.

Luego realizamos el programa principal con un VOID MAIN () para que se abra el

programa principal seguido con la llave { y declaramos las demás variables a realizar

en el programa (int vector1[10],fila,op,lim;), después ponemos un do-while

para que se repita el programa n veces y llamamos las funciones realizadas y

realizamos el ingreso del límite para que podaos ingresar datos a una función y que

luego se visualice.

CODIGO

#include<stdio.h>

#include<conio.h>

int i;

void borde()

{

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

{



}

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

{



}

}

Librerías que vamos a utilizar en el

Declaramos la variable

global

Realizamos la función para que se

pueda realizar un borde en nuestro


void main()

{

int vector1[10],fila,op,lim;

do

{

clrscr();

borde();

gotoxy(25,3); printf("**VISUALIZAR DATOS VECTOR**");

gotoxy(10,5); printf("INGRESE EL LIMITE==>");

scanf("%d",&lim);

fila=6;

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

{

do

{

gotoxy(20,fila); printf(" ");

gotoxy(20,fila); scanf("%d",&vector1[i]);

}

while(vector1[i]<3 || vector1[i]>23);

fila=fila+1;

}

fila=6;

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

{

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

fila=fila+1;

}

gotoxy(10,20); printf("PRESIONE 1 PARA REPETIR EL PROGRAMA CASO

CONTRARIO 0==>");

scanf("%d",&op);

Realizamos el programa principal y declaramos la

variables que vamos a utilizar en el programa

Aquí damos un limite al

vector para poder dar datos

numéricos a un limita vector

Ingresamos el

Ingresamos los números para que se

llene el vector previamente dado un

Damos o validamos los datos que estén entre 3 y

Aquí se visualiza el vector

que ingresamos en otra

Ingresamos otra opción para ver si se repite el programa n


}

while(op);

getch();

}

CORRIDO

Visualiza la opción y da por terminado el

programa



Diseñe un programa utilizando vectores y un menú de opciones que me permita

realizar las 4 operaciones básicas, estas son: suma, resta, multiplicación y división.

ANALISIS

En este programa se realizan las operaciones básicas que son la suma, resta,

multiplicación y división utilizando un menú de opciones y con vectores, en donde

tenemos que ingresar valores en dos vectores diferentes en el vector1 y vector2

para que vayan realizando las operaciones correspondiente teniendo en cuenta las

condiciones plantedas que se dieron en la resta y división en donde el valor del

vector1 debe ser mayor al valor del vector2 si no se cumple la condición no se

realiza las operaciones y se imprime un mensaje.

CDIFICACION

#include<stdio.h>

#include<conio.h>

#include<stdlib.h>

int multivec[15],opc,divisionvec[15],

restavec[15],i,op,col,fila,vector1[15],vector2[15],

sumavec[15],limite1;

void borde()

{

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

{



}

Ingreso las

librerías

Declaración de

variables

Función borde

Este proceso es

para realizar el

borde


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

{



}

}

void ingreso(int limite1)

{

col=12;

fila=8;

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

{

gotoxy(col,fila); scanf("%d",&vector1[i]);

gotoxy(col+10, fila); scanf("%d",&vector2[i]);

fila=fila+1;

}

}

void suma(int limite1)

{

fila=8;


{

sumavec[i]=vector1[i]+vector2[i];

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

fila=fila+1;

Función para ingresar los valores

de los vectores

Ingresamos la posición en la cual

se va a visualizar los vectores

Utilizamos el for para poder

ingresar los valores del vector1 y

vector2 al final vamos sumando fila

para q vayan colocándose en las

posiciones correctas, cerramos la

laves del for y la llaves de la

función ingreso.

Función para realizar la suma

Abrimos con una llave

Ingresamos el valor de la fila en la que va a

empezar a visualizarse los datos del vector.



vector2, realizamos la operación en

donde se suman los dos vectores e

imprimimos el resultado, vamos

sumando fila para las correctas

posiciones cerramos el for y la

función suma.


}

}

void resta(int limite1)

{

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)

{

fila=8;

Función para realizar la resta





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

Función para realizar la multiplicación






{

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

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

fila=fila+1;

}

}

void division(limite1)

{

fila=8;


{

if(vector1[i]>=vector2[i])

{

divisionvec[i]=vector1[i]/vector2[i];

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

}

else

{

gotoxy(40,fila);

printf("NO SE PUEDE CALCULAR");

}

fila=fila+1;

}

}



vector2, realizamos la operación en

donde se mulitiplican los dos

vectores e imprimimos el resultado,

vamos sumando fila para las

correctas posiciones cerramos el

for y la función multi.

Función para realizar la división.





ingresar los valores del

vector1 y vector2, luego se

utiliza un if para indicar que

el vector1 debe ser mayoro

igual que el vector2 si la

condición se cumple

realizamos la operación en

donde se dividen los valores

del vector que sea mayor e

imprimimos el resultado,

cerramos el if y si no se

cumple la condición

escribimos un mensaje y no

se realiza la operación,

cerramos la llaves y vamos

sumando fila para las

correctas posiciones


void main()

{

do

{

clrscr();

borde();

gotoxy(15,3); printf("**OPERACIONES CON VECTORES Y FUNCIONES**");





gotoxy(10,13); printf("QUE OPCION DESEA==>");

scanf("%d",&op);

switch(op)

{

case 1:

do

{

clrscr();

borde();

gotoxy(30,3);printf("1.-SUMA");

gotoxy(11,7); printf("VECTOR 1");


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


scanf("%d",&limite1);

Función principal del programa.


Utilizamos el ciclo do while para que el proceso se repita tantas veces desee el usuario

Limpia la pantalla.

Llama a la función borde.

Diseño de pantalla.

Utilizamos la sentencia

switch para el menú de

opciones.


ingreso(limite1);

suma(limite1);

gotoxy(10,23);

printf("SI DESEA REPETIR EL

PROCESO PRESIONE 1 CASO

CONTRARIO 0==>");

scanf("%d",&opc);

}

while(opc==1);

break;

case 2:

do

{

clrscr();

borde();




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



ingreso(limite1);

resta(limite1);

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

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

scanf("%d",&opc);

}

Diseño de la segunda

opción del menú de

opciones llamamos a las

funcione y utilizamos el

ciclo do while pa repetir el

proceso la veces que

desee el usuario, lo


while(opc==1);

break;

case 3:

do

{

clrscr();

borde();




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

borde();


Diseño de la tercera





proceso la veces que

desee el usuario, lo

Diseño de la cuarta








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



ingreso(limite1);

division(limite1);

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

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

scanf("%d",&opc);

}

while(opc==1);

break;

}

clrscr();

borde();

gotoxy(10,23);

printf("SI DESEA VOLVER AL MENU PRESIONE 1 CASO CONTRARIO O==>");

scanf("%d",&op);

}

while(op==1);

getch();

}

CORRIDO

Cerramos el switch

limpiamos pantalla y

volvemos a llamar a la

función borde.

Cerramos el ciclo do while

escribiendo un mensaje

Pausa.

Cerramos la función main.


Programa 39

Enunciado

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

Análisis

Ingresar el vector de entrada

Visualizar en un nuevo vector los vectores de entrada

Código

#include<stdio.h>

#include<conio.h> Liberia principal

int vector1[100],fila=10, i,lim; Declaracion de variables globales

void borde() Inicio de funcion

{

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

{



}

for(i=1;i<=24;i++) proceso para realizer el borde

{



}

}


void entrada() Inicio de la función

{

gotoxy(23,8);printf("Ingreso:"); Mensaje en la pantalla

gotoxy(20,6);printf("Ingrese el limite:");scanf("%d",&lim); Ingresar la variable

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

{ Inicio de lazo for

do

{ inicio de un lazo do para que genere n veces

gotoxy(25,fila);printf(" "); recorrido de espacio

gotoxy(25,fila);scanf("%d",&vector1[i]); leer la variable

}while(vector1[i]<3||vector1[i]>23); cierre de validacion datos

fila=fila+1;

} Cierre de lazo for

} Fin de la función

void salida()

{ Inicio de la función

fila=10;

gotoxy(57,8);printf("Salida:"); Mensaje en la pantalla

for(i=1;i<=lim;i++) Inicio de un lazo for de un limite dado hasta un limite dado

{

gotoxy(60,fila);printf("%d",vector1[i]); Impremir el resultado

fila=fila+1;


} cierre de la funcion

main() Inicio de programa principal


{

clrscr(); Blanqueado de pantalla

borde(); Llamada de la función de borde

gotoxy(31,4);printf("PRESENTACION DE VECTORES"); Mensaje en la pantalla

entrada();

salida(); Llamada de la funciones

getch(); pausa en la pantalla

} Fin de programa principal

Corrido


Programa 40 Enunciado

Diseñe un programa utiliza do vectores y funciones que me permita sumar los datos ingresados y

validados de un vector y presentar la sumatoria en un vector resultante.

Análisis

Ingresar los datos y validar de un vector

Representar la sumatoria en un nuevo vector

Código

#include<stdio.h> Librería s principales

#include<conio.h>

int vector1[15],vector2[15],sumavector[15],fila=10,lim,i,col=20,op; declareacion devariables

globales

void borde()

{ Inicio de la funcion

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

{



}

for(i=1;i<=24;i++) proceso para realizer el borde

{



}

}


void ingreso(int limite1) Inicio de la funcion

{

for(i=1;i<=limite1;i++) Inicio de un lazo for

{

gotoxy(col,fila);scanf("%d",&vector1[i]); leer la variable

gotoxy(col+10,fila);scanf("%d",&vector2[i]);

fila=fila+1; posiciones en la pantalla


} Cierre la llave de funcion

void suma(int limites) Inicio de a funcion

{

fila=10; Posicion en la pantalla

gotoxy(50,8);printf("vector resultante"); Mensaje en la pantalla

for(i=1;i<=limites;i++) Inicio de un lazo for

{

sumavector[i]=vector1[i]+vector2[i]; formula para realizar la suma

gotoxy(60,fila);printf("%d",sumavector[i]); Imprimir el resultado

fila=fila+1; posicion en la pantalla


} Cierre de la funcion

main()

{

Do inicio de lazo do para la validacion de datos

{

fila=10;


clrscr(); Blanqueado de pantalla

borde(); Llamada de la función

gotoxy(31,4);printf("SUMA DE VECTORES");

gotoxy(15,8);printf("vector 1:"); Mensaje en la pantalla

gotoxy(27,8);printf("vector 2:");

gotoxy(22,6);printf("Ingrese el limite:");scanf("%d",&lim); Leer la variable

ingreso(lim);

suma(lim); Llamada de la funciones

getch(); Pausa en la pantalla

gotoxy(10,22);printf("Desea realizar otra suma 1, salir 0>> ");scanf("%d",&op);Leer la variable

}while(op==1); Cierre de lazo for de validación de datos

} Fin de programa principal

Corrido


Programa 42 Diseñe un programa utilizando funciones que me permita ingresar n números en un vector entre 6 y

26, recorra el vector y encuentre todas las posiciones pares y asígnelas a un nuevo vector, recorra el

vector original y encuentre todas las posiciones impares del vector y asígnelos a un nuevo vector,

visualice el vector de entrada y los vectores resultantes.

ANALISIS:

Nos pedirá ingresar un límite de datos y al frente nos debe imprimir en un vector los datos de las

posiciones pares y en otro vector nos imprimirá los datos de las posiciones impares. Como así

también nos genera un borde como diseño del programa, y como final tenemos ingresar uno para

continuar utilizando nuestro programa o 0 para salir del mismo.

CODIFICADO:

#include<conio.h>

#include<stdio.h>

#include<stdlib.h>

int i, j=1, f, vect[10], vectpar[10], vectimp[10], op, l;

void bdob()

{

int i;

clrscr();

gotoxy(1,1);printf("*");


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

{



}



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

{



Activación de librería esto

habilita procesos para el

programa Declaración de

variables que se

utilizaran en el

programa

Función borde

Generación del borde

utilizando posiciones e

imprimiendo el borde

que va a ir en pantalla


}

}

void par()

{

j=1;

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

{

if(i%2==0)

{

vectpar[j]=vect[i];

j=j+1;

}

}

f=10;

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

{

gotoxy(39,f);printf("%d",vectpar[i]);

f=f+1;

}

}

void impar()

{

j=1;

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

{

if(i%2==1)

{

vectimp[j]=vect[i];

j=j+1;

}

Proceso de comparación si

la posición es par y se

almacenara en un nuevo

vector y se imprimirá en

pantalla utilizaremos el

gotoxy para posiciones en

Función para ver si la posición es

impar

Comparación si la función es

impar

Almacenamiento en un nuevo

vector


}

f=10;

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

{

gotoxy(60,f);printf("%d",vectimp[i]);

f=f+1;

}

}

void main()

{

do

{

flushall();

f=10;

clrscr();

bdob();

gotoxy(36,3);printf("VECTORES");

gotoxy(5,5);printf("Ingrese el limite>> ");scanf("%d",&l);

gotoxy(15,8);printf("VECTOR 1");

gotoxy(29,8);printf("POSICIONES IMPAR");

gotoxy(51,8);printf("POSICIONES PAR");

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

{

gotoxy(3,f);printf("INGRESO %d::",i);

do

{

gotoxy(20,f);printf(" ");

gotoxy(20,f);scanf("%d",&vect[i]);

}

while(vect[i]<6 || vect[i]>26);

f=f+1;

Impresión de datos de las

posiciones impares

Programa principal

Do while este nos ayuda a

utilizar el programa cuantas

veces deseemos

Limpia pantalla

Llama a la función del

Pide ingresar un limite de

generación de datos

Ingreso de datos del

vector

Validación de los datos,

estos deben ser mayor que

seis y menor que veinte y


}

par();

impar();

gotoxy(3,22);printf("PRESIONE 1 PARA CONTINUAR O 0CASO CONTRARIO::> ");scanf("%d",&op);

}

while(op==1);

getch();

}

CORRIDO:

Llama a la función par

Llama a la función

Cierre del do while

Cierre o fin del


Programa 43 Diseñe un programa utilizando funciones y vectores que me permita generar un vector de posiciones

pares con la serie del fibonasi y las posiciones impares con el factorial.

ANALISIS:

Nos pedirá ingresar un limite de datos con ello nos generara internamente el fibonaci y factoreal y

nos imprimirá las posiciones impares con el fibonaci y las posiciones pares con el factoreal.

CODIFICADO:

#include<conio.h>

#include<stdio.h>

int i,n,op,a,b,c,vect[25],fi;

float f;

void borde()

{

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

{





}

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

{





}

}

void serie(int m)

{

a=1;

LIBRERIAS QUE HABILITAN

PROCESOS PARA LA ELABORACION

DEL PROGRAMA.

ELABORACION DE UN BORDE PARA

DISEÑO DE PANTALLA UTILIZANDO

POSICIONES.

FUNCION SERIE DONDE

GENERARA EL FIBONACI Y EL

IGUALACION DE VARIABLE. DESDE

QUE NUMERO DESEAMOS QUE

EMPIESE


b=0;

f=1;

gotoxy(9,6);printf("FIBONACI FACTOREAL");

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

{

f=f*i;

c=a+b;

a=b;

b=c;

gotoxy(15,8+i);printf("%d",c);

gotoxy(25,8+i);printf("%0.0f",f);

if(i%2==0)

{

vect[i]=c;

}

else

{

vect[i]=f;

}

}

fi=9;

gotoxy(40,6);printf("POSICION");

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

{

gotoxy(45,fi);printf("%d",vect[i]);

fi=fi+1;

}

}

void main()

{

do

IMPRIMIRA LOS MENSAJES QUE

DESEEMOS

REALIZARA OPERACIONES PARA

CALCULAR FIBONACI Y

IMPRIMIRA LOS RESULTADOS

DE FIBONACI Y FACTOREAL

COMPRUEBA SI LA POSICION ES

PAR O IMPAR

PROGRAMA PRINCIPAL

CICLO DO WHILE ESTE

AYUDARA A REGRESAR AL

PROGRAMA CUANTAS VECES


{

clrscr();

borde();

gotoxy(30,2);printf("... SERIE CON VECTORES ...");

gotoxy(10,4);printf("LIMITE::> ");scanf("%d",&n);

serie(n);

gotoxy(15,22);printf("DESEA CONTINUAR DIJITE 1 CASO CONTRARIO 0 ==> ");scanf("%d",&op);

}while(op==1);

getch();

}

CORIIDO:

Programa 44 1.- Enunciado:

Diseñe un programa utilizando funciones y vectores que me permita ingresa n

elementos en un vector entre 3 y 33, recorre el vector y encontrar todos los datos

LLAMAMOS A LA FUNCION

DEL BORDE

INGRESAREMOS UN LMITE

CIERRE O FIN DEL

PROGRAMA


pares y asignarlos a un nuevo vector, encontrar todos los datos impares y asignarlos

a un nuevo vector, visualice tanto el vector de entrada como los vectores resultantes.

2.-Codicifcado:

#include<conio.h>

#include<stdio.h>

int i, f, vect[100], vectbusq[100], lim, op;

void bdob()

{

int i;

clrscr();

textcolor(i);gotoxy(1,1);cprintf("É");

gotoxy(80,1);cprintf("»");

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

{

textcolor(i);

gotoxy(i,1);cprintf("Í");

gotoxy(i,24);cprintf("Í");

}

gotoxy(1,24);cprintf("È");gotoxy(80,24);cprintf("¼");

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

{

textcolor(i);

gotoxy(1,i);cprintf("º");gotoxy(80,i);cprintf("º");

}

}

void busq(int l)

{

Librerías principales

Variables Globales

Nuestro Borde

acompañado de una

Función.

Función donde realizaremos el proceso del ejercicio

Abrimos llave para nuestra Función.


f=9;

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

{

if(vect[i]%2==0)

{

gotoxy(34,f);printf("%d",vect[i]);

f=f+1;

}

}

f=9;

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

{

if(vect[i]%2==1)

{

gotoxy(55,f);printf("%d",vect[i]);

f=f+1;

}

}

}

void main()

{

Igualación de variables

Este for nos indica el límite y

abrimos la llave del primer for.

Dentro del for realizamos un if

donde nos indica si la división es

igual a cero es para el número

par, e imprimimos en un nuevo

vector el resultado en caso que

sea número par.

Cerramos la llave del primer for

Igualación de la variable

Este es un segundo for nos indica el límite

y abrimos llave para inicializar el for.

Dentro del segundo for

realizamos un if donde nos

indica si el residuo de la división

es 1 su respuesta es impar,

abrimos llaves e imprimimos el

resultado impar en un nuevo

vector, y cerramos las llaves del

for como del if y de la función.

Comenzaremos con el programa principal.


do

{

clrscr();

bdob();

gotoxy(21,3);printf("<<BUSQUEDA DE # PARES E IMPARES_VECTORES>>");

gotoxy(5,5);printf("Ingrese el limite>> ");scanf("%d",&lim);

gotoxy(13,7);printf("<<VECTOR>>");

gotoxy(26,7);printf("<<NUMEROS PARES>>");

gotoxy(47,7);printf("<<NUMEROS IMPARES>>");

f=9;

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

{

do

{


gotoxy(18,f);scanf("%d",&vect[i]);

}

while(vect[i]<3 || vect[i]>33);

f=f+1;

}

busq(lim);

Abrimos la sentencia.

Limpiar pantalla.

Llamamos a la función borde.

Impresión de mensajes

Posición de fila

Este for nos indica el límite e abrimos

Este es un Do While interno nos indica que

imprimiremos la respuesta e ingresamos el

vector, el While nos indica si él un vector

es menor que 3 o mayor que 33.

Declaramos la posición de fila.

Cerramos llave

Llamamos a la

función


gotoxy(3,22);printf("Presione 1 para volver a ingresar vectores o 0 para finalizar>>

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

}

while(op==1);

getch();

}

3.- Análisis del programa:

Primero ingresamos las librerías las cuales son muy importantes.

Luego realizamos un for donde nos permite hacer el borde de nuestro

programa.

Realizamos una función en la cual hacemos el proceso de los números pares

e impares con vectores.

Para finalizar abrimos la función principal donde llamamos a las demás

funciones para que se realice el proceso y asi finalizamos nuestro programa,

y obtenemos lo que deseamos.

4.-Corrido del Programa:

Programa 45 Diseñe un programa en c utilizando vectores y funciones que me permita generar con cualquier

factor impar ingresado desde teclado las posiciones pares del vector, y con um factor par las

posiciones impares del vector.

Imprimimos el mensaje

Aquí cerramos la llave del ciclo do while

damos pause a nuestro programa y cerramos

llave.

Librerías


#include<stdio.h> #include<conio.h> int j,fila,vecfi[10],i,f1,f2,limite,facpar,facimp,op; void borde() { for(i=1;i<=24;i++) { gotoxy(2,i);printf("-"); gotoxy(80,i);printf("-"); } for(i=1;i<=80;i++) { gotoxy(i,2);printf("-"); gotoxy(i,24);printf("-"); } } void factor() { fila=10; int limitetab; limitetab=0; for (j=1;j<=limite;j++) { if(j%2!=0) { limitetab=limitetab+1; vecfi[i]=facpar*limitetab; gotoxy(10,fila);printf("%d",vecfi[i]); fila=fila+1; } else { vecfi[i]=facimp*limitetab; gotoxy(10,fila);printf("%d",vecfi[i]); fila=fila+1; } } } void main() { do { clrscr(); borde(); gotoxy(8,4);printf("Ingrese el limite: "); scanf("%d",&limite); do { gotoxy(5,6); printf(" "); gotoxy(5,6);printf("par:");scanf("%d",&facpar); } while(facpar%2==1);


Función global para el

borde, e inicio del ciclo, da

color


factor y del ciclo for

Condición para calcular los

factores impares y pares

Inicio del programa

principal

Inicio de el ciclo do while

llamamos al borde ye

ingresamos el limite

Ingreso de los

números pares


do { gotoxy(5,7); printf(" "); gotoxy(5,7);printf("impar: ");scanf("%d",&facimp); } while(facimp%2==0); factor(); gotoxy(3,22); printf("nuevo proceso 1 salir 0: "); scanf("%d",&op); } while(op==1); getch(); }

Programa 46 Diseñe un programa utlizando vectores y funciones que me permita ordenar un vector en forma

ascendente y descendente. Ingresado entre 6 y 26.

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

Ingreso de los impares,

repetición del proceso y

fin del programa

Librerías, declaración de

variables he inicio de la

función borde


int i,conta,residuo,j,op,fila=5,k,aux,limite,vec[10]; void borde() { for(i=1;i<=79;i++) { gotoxy(i,1);printf("-"); gotoxy(i,23);printf("-"); } for(i=1;i<=23;i++) { gotoxy(1,i);printf("-"); gotoxy(79,i);printf("-"); } } void ingreso() { int fila=5; for(i=1;i<=limite;i++) { do { gotoxy(5,fila);printf(" "); gotoxy(5,fila);scanf("%d",&vec[i]); } while((vec[i]<6)||(vec[i]>26)); fila=fila+1; } } void ascendente () { int fila=5; for (i=1;i<=limite;i++) { for (j=1;j<=limite;j++) { if (vec[i]<vec[j]) { aux=vec[i]; vec[i]=vec[j]; vec[j]=aux; } } } for (i=1;i<=limite;i++) { gotoxy(40,fila);printf("%d",vec[i]); fila=fila+1; } } void descendente () {

Proceso de borde

Inicio de la función para

el ingreso con un rango

entre 6 y 26

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


int fila=5; for (i=1;i<=limite;i++) { for (j=1;j<=limite;j++) { if (vec[i]>vec[j]) { aux=vec[i]; vec[i]=vec[j]; vec[j]=aux; } } } for (i=1;i<=limite;i++) { gotoxy(55,fila);printf("%d",vec[i]); fila=fila+1; } } void main() { do { clrscr(); borde(); gotoxy(3,2);printf("ingrese el limite....: ");scanf("%d",&limite); gotoxy(2,4);printf("INGRESO"); gotoxy(30,4);printf(" ASCENDENTE DESCENDENTE"); ingreso(); ascendente(); descendente(); gotoxy(3,22);printf("pulse 1 para volver y salir 0.....: ");scanf("%d",&op); } while (op==1); getch(); }


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

Usamos una

condición Y

para la

impresión un

for mas para el

Inicio del

programa

principal

llamamos

funciones he

ingresamos el

limite


factorial en las posiciones pares del vector presente en el vector ordenado en forma

ascendente y descendente

CODIFICACION

#include<stdio.h>

#include<conio.h>

int op,i,j,limite,au,aux,mu,factor,fa,fila,vecto[15];

void borde()

{

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

{



}

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

{



}

}

void facto()

{

Ingreso las

librerías

Declaración de

variables

Función borde

Este proceso es

para realizar el

borde

Función de la

serie

Igualación de las

variables


fila=9;

mu=0;

au=1;

factor=1;

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

{

if(i%2==1)

{

mu=mu+fa;

vecto[i]=mu;

}

else

{

factor=factor*au;

au=au+1;

vecto[i]=factor;

}

gotoxy(7,fila);printf("%d",vecto[i]);

fila=fila+1;

}

}

void orden()

{

Que el for vaya

hasta el límite

En este proceso es para

que podamos sacar los

números impares

donde el número

ingresado lo dividimos

para 2 sino caso

contrario sacamos el

factor y después vamos

a imprimir el vector [i]

donde después vamos a

Ingresamos una

nueva función que

se llama orden



{

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

{

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

{

aux=vecto[i];

vecto[i]=vecto[j];

vecto[j]=aux;

}

}

}

fila=9;


{


fila=fila+1;

}

fila=9;


{

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

{

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

{

aux=vecto[i];

vecto[i]=vecto[j];

vecto[j]=aux;

Este proceso nos

sirve para ordenar el

vector en forma

ascendente vamos a

mandar dos for uno

que es interno y otro

que es externo

donde el vector

[i]sea menor que el

vector[j] después

vamos a mandar

otro for que vaya

Este proceso nos

sirve para ordenar el

vector en forma

ascendente vamos a

mandar dos for uno

que es interno y otro

que es externo

donde el vector

[i]sea mayor que el


}

}

}

fila=9;


{


fila=fila+1;

}

}

void main()

{

do

{

clrscr();

borde();

gotoxy(25,3);printf("FacPares/Impares");

gotoxy(12,5);printf("Ingrese el limite: ");scanf("%d",&limite);

gotoxy(10,7);printf("Factor: ");scanf("%d",&fa);

facto();

orden();

Abro el programa

Abro el do

Llama a la función

de borde

Limpio de pantalla

Posición en donde

que quiero que se

me imprima printf

Llama a la función

de borde

Limpio de pantalla

Posición en donde

que quiero que se

me imprima printf

Pide el límite que

quieres imprimir Pide el factor que

quieres imprimir

Llamo a la función

facto

Llamo a la función

orden

Después vamos a

mandar otro for que

vaya hasta el límite y

después vamos a

imprimir el vector [i]


gotoxy(5,20);printf("Presione 1 para repetir el proceso o 0 para salir: ");scanf("%d",&op);

}

while(op==1);

getch();

}

CORRIDO

ANALISIS

En este programa presentado, vamos a trabajar con funciones y vectores donde tenemos

que la posiciones impares se me ubique el número ingresado y el factorial tiene que ubicarse

en las posiciones pares del vector donde después vamos a ordenar el vector en orden

ascendente y en orden de é z “ ”

se utilizara para la opción desea continuar SI o NO, esto se lo realiza con el Laso DO – WHILE

que permite generar nuevamente el programa.

PROGRAMA 48

ENUNCIADO

Se me imprime

mensaje para

continuar o terminar

el programa

Cierro la función

de do-while

Cierro el

programa


Diseñe un programa con funciones y vectores que me permita ingresar un sin

número de elementos en un vector entre 3 y 25, recorrer el vector y encontré

todos aquellos valores que sean números primos asígnelos en un nuevo

vector y preséntelos ordenados en forma ascendente y descendente.

ANÁLISIS

Para realizar este programa necesitamos utilizar funciones tanto para el borde como

para los números primos y para ordenar dichos números en forma ascendente y

descendente.

Para el vector que vamos a ingresar necesitamos un ciclo do while el mismo

que debemos condicionarlo para que este vector ingresado sea menor que 3

o mayor que 25, este proceso debemos realizarlo dentro de una función a la

cual denominaremos pri ya que también dentro de esta función realizaremos

las operaciones para encontrar los números primos para lo cual necesitamos

de la condición if y de ciclos for los cuales nos ayudaran a generar dichos

números.

Par ordenar el vector de forma ascendente y descendente necesitamos de

una función denominada as para la forma ascendente y de una función

denominada des para la forma descendente dentro de las cuales se

encontrara un ciclo for el mismo que nos ayudara a realizar dicho proceso e

imprimirlo tanto ascendente como descendente.

Además utilizamos un ciclo do while para repetir este proceso el número de

veces que el usuario desee.

.

DOCUMENTACIÓN

#include<conio.h>

#include<stdio.h>

int f1, aux, num, i, j, f, vect[100];

int vectser[100], lim, op, cont;

void borde()

{

int i;

clrscr();



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

Ingresamos las librerías que vamos a

Ingresamos las variables que vamos a utilizar, son

variable de tipo enteras


{



}



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

{



}}

void primo(int l)

{

f=9;

f1=9;

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

{

do

{


gotoxy(18,f);scanf("%d",&vect[j]);

}

while(vect[j]<3 || vect[j]>25);

f=f+1;

cont=0;

for(i=1;i<=vect[j];i++)

{

if(vect[j]%i==0)

{

cont=cont+1;

}}

if(cont==2)

{

vectser[j]=vect[j];

gotoxy(34,f1);printf("%d",vectser[j]);

f1=f1+1;

}}}

void orden(int l)

{

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

{

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

{

Esta función es para poder ordenar al vector de manera ascendente y

descendente Realizamos dos for para que se de un límite y se pregunte a las dos

posiciones, y después de le pregunta con un if si el vector [i] es < que el

Aquí realizamos una función para

poder realizar el borde en el

programa

Aquí realizamos una función para

poder verificar si un número es o no

Aquí imprimimos y validamos el vector ingresado que

este entre parámetro que nos dieron para realizarlo

Sumamos a la fila (f=f+1), y igualamos a cero el

Este for es para que se imprima en las filas

Este if es para que se imprima en las filas


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

{

aux=vectser[i];

vectser[i]=vectser[j];

vectser[j]=aux;

}}}

gotoxy(29,9);printf("ASCE");

f=11;

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

{

gotoxy(39,f);printf("%d",vectser[i]);

f=f+1;

}

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

{

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

{

if(vectser[i]>vectser[j])

{

aux=vectser[i];

vectser[i]=vectser[j];

vectser[j]=aux;

}}}

gotoxy(52,9);printf("DESC");

f=11;

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

{

gotoxy(62,f);printf("%d",vectser[i]);

f=f+1;

}}

void main()

{

do

{

clrscr();

borde();

gotoxy(21,3);printf("BUSQUEDA DE NUMRS- PARES E IMPARES");

gotoxy(5,5);printf("limite: ");scanf("%d",&lim);

gotoxy(13,7);printf("VECTOR");

gotoxy(26,7);printf("#PRIMOS");

gotoxy(47,7);printf("#IMPARES");

primo(lim);

orden(lim);

Aquí utilizamos una variable auxiliar

para que tome el valor de otra

Igualamos la fila a

11

Imprimimos al vector de manera

ascendente

Estos for son para que se

imprima hasta un cierto límite.

Aquí utilizamos una variable auxiliar

para que tome el valor de otra

Imprimimos al vector de manera

descendente

Realizamos el programa

principal

Ponemos una sentencia do-while para que se pueda repetir n

veces.

Ingresamos el

límite e

imprimimos un

título

Llamamos a las demás funciones que ya


gotoxy(3,22);printf("Otra vez si1/no 0: ");scanf("%d",&op);

}

while(op==1);

getch();

}

CORRIDO DEL PROGRAMA

PROGRAMA 49

ENUNCIADO Diseñe un programa utilizando funciones que me permita leer una cadena de

caracteres ingresado desde teclado y que a su vez cuente la cantidad de caracteres

de dicho vector.

Cerramos el lazo do-

Terminamos con un getch(); y con la


ANÁLISIS

En este programa por medio de funciones podemos realizar tanto el borde como

para colocar la cadena de caracteres e imprimirla y para encontrar los datos de las

posiciones impares del vector.

Para colocar la cadena de caracteres en una posición e imprimirla

necesitamos de una función a la cual la denominaremos void cad para

realizar dicho proceso requerimos de un ciclo for el mismo que nos permitirá

imprimir la cadena de caracteres deseada y añadirle color.

Para encontrar los datos de la cadena de caracteres del vector necesitamos

de una nueva función a la cual la denominaremos void cont para realizar

dicho proceso requerimos de un ciclo for el cual nos permitirá contar los

caracteres ingresados además requerimos de otro ciclo for el mismo que nos

ayudara a imprimir dichos datos.

Además utilizamos un ciclo do while para repetir este proceso el número de

veces que el usuario desee.

DOCUMENTACIÓN

#include<stdio.h>

#include<conio.h>

#include<string.h>

#include<ctype.h>

char cadena[20],vecimpar[20];

int i,fi,op,n,h;

void borde()

{

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

{

textcolor(i+1);



}

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

{

textcolor(i+1);



Librerías

Declaracion de variables tipo

Fin ciclo for

Impresión borde

color

Inicio función borde

Inicio ciclo for

color

Impresión borde

Fin ciclo for

Inicio ciclo

Declaracion de variables


}

}

void cad()

{

flushall();

gotoxy(30,5);gets(cadena);

l=strlen(cadena);

fila=9;

for(i=0;i<l;i++)

{

textcolor(i+1);

gotoxy(23,fi);cprintf("%c",cadena[i]);

fila=fila+1;

}

}

void cont()

{

h=1;

for(i=0;i<n;i++)

{

vecimpar[h]=cadena[i];

h=h+1;

}

fila=8;

for(i=0;i<h;i++)

{

gotoxy(45,fi);printf("%c",vecimpar[i]);

fila=fila+1;

}

}

void main()

{

do

{

clrscr();

borde();

gotoxy(25,3);printf("<< CARACTERES >>");

gotoxy(8,5);printf("*.CARACTERES : ");

gotoxy(15,7);printf("<< V REALIZADO>>");

gotoxy(38,7);printf("<< V.RESULTANTE>>");

cad();

cont();

gotoxy(12,22);printf("PULSE 1 PARA CONTINUAR O 0 PARA SALIR : ");scanf("%d",&op);

Inicio función cad Fin función borde

Palabra reservada que permite funcionar ciclo do

Impresión

Igualación limite palabra reservada Igualación fila a 9

Inicio ciclo for

Impresión vector

Inicio función cont

Igualación variable a 1 Inicio ciclo

Igualación vector auxiliar a vector

ingresante

Contador mas 1 Fin ciclo for

color

Fin función cadena

Contador mas 1 Fin ciclo for

Igualación variable fila a

8 Inicio ciclo

Impresión vector resultante Contador mas 1

Fin ciclo for Fin funcion

Inicio función principal

Inicio ciclo do

Blanqueo de

pantalla Se llama a la funcion borde

Impresión titulos

Se llama a la funcion Se llama a la función cont

Impresión

repetición


}

while(op==1);

getch();

}


Programa 50 Diseñe un programa en c++ utilizando funciones que me permita leer una cadena de caracteres,

ingresar desde teclado un caracter que desee buscar en la cadena ingresada, asignela a un nuevo

vector e imprimalo en un vector resultante.

Fin ciclo do

Fin

programa


#include<stdio.h> #include<conio.h> #include<string.h> #include<ctype.h> char nombre[20],a; int i,fi,n,op, cont; void borde() { for(i=1;i<=79;i++) { textcolor(17); gotoxy(i,1);cprintf("*"); gotoxy(i,24);cprintf("*"); } for(i=2;i<=23;i++) { textcolor(17); gotoxy(1,i);cprintf("*"); gotoxy(80,i);cprintf("*"); } } void nomb() { flushall(); gotoxy(12,5);gets(nombre); n=strlen(nombre); fi=5; for(i=0;i<n;i++) { if(islower (nombre[i])) { nombre[i]=toupper(nombre[i]); textcolor(i+1); gotoxy(40,fi);cprintf("%c",nombre[i]); fi=fi+1; } if(nombre[i]==a) { cont=cont+1; textcolor (3); gotoxy(30,10);cprintf("Letras>> %d",cont); }} } void main() { do {

Abrimos las

Iniciamos los valores de nuestro programa

Nuestro borde

Función que

ocuparemos después

Permite leer el carácter

Permite almacenar en otro

For para ingresar el vector,

utilizamos la función textcolor

para poner color a las letras

For para ingresar el vector,

utilizamos la función textcolor

para poner color a las letras

Comenzaremos con el

programa principal

Abrimos la Sentencia

do

Borrado de pantalla y llamado de la función

borde Llamamos a las funciones


clrscr(); borde(); nomb(); textcolor(2); gotoxy(12,18);cprintf("ingrese el caracter ");scanf("%c",&a); textcolor(3); for(i=0;i<n;i++) { if(nombre[i]==a) { cont=cont+1; }} textcolor (3); gotoxy(15,15);cprintf("Letras>> %d",cont); gotoxy(12,22);cprintf("desea repetir 1 salir 0: ");scanf("%d",&op); }while(op==1); getch(); }

ANALISIS:

Primero empezamos abriendo nuestras bibliotecas

Después validamos nuestras variables globales, que servirán para la

ejecución de nuestro programa, teniendo en cuenta que estamos

ocupando char que servirá para hacer cadena de caracteres.

Realizamos nuestra primera función llamada borde que nos servirá para

más después abrir en nuestras funciones realizadas

Comenzamos a realizar nuestra primera función llamada nomb, en esta se

guardaran todos los procesos para poder hacer nuestro primer programa

donde está el ingreso y las etiquetas de nuestro programa, además

ingresaremos el carácter y un proceso de for en el cual se almacenen un

vector con sus respectivos caracteres.

Después de esto comenzaremos otra función llamado impar, en la cual

haremos todos los procesos respectivos a nuestro segundo programa el

cual ira comparando las posiciones impares de nuestro vector anterior y

ahora irlo almacenando en un vector nuevo.

Por ultimo realizaremos nuestro programa principal en el cual solo

llamaremos a nuestras anteriores funciones en las cuales se han guardado

todos los procesos de cada programa, llamaremos a nuestro borde i

limpiado de pantalla

Por ultimo haremos que se repita nuestro programa con una sentencia do

while y cerraremos nuestro programa.

CORRIDO DEL PROGRAMA:

Cerramos la sentencia do

while

Pausado en el programa y

cerrado del programa

Imprimir el título y

subtítulos de nuestro

For para su limite y el if para

buscar su posición par


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

Empezamos abriendo las librerías para activar funciones, utilizamos variables de

tipo enteras y alfabéticas tres funciones con sentencia “for”, una para el borde y

las dos restantes para realizar los procesos y al impresión de las letras qu

están en las posiciones impares, un do-while para repetir los procesos cuantas

veces se desee, empezamos el programa con viod main, llamamos a las

funciones, e imprimimos resultados.

DOCUMENTACION

#include<stdio.h> #include<conio.h> #include<string.h> #include<ctype.h> char nombre[20],vecimpar[20]; int i,fi,op,n,h; void borde() { for(i=1;i<=79;i++) { textcolor(9); gotoxy(i,1);printf("±"); gotoxy(i,24);printf("±"); } for(i=2;i<=23;i++) { textcolor(9); gotoxy(1,i);printf("±"); gotoxy(80,i);printf("±"); } } void nomb() { flushall(); textcolor(3); gotoxy(5,5);cprintf("TEXTO:"); textcolor(i+1); gotoxy(12,5);gets(nombre); n=strlen(nombre);

Librerías.- colección de clases y funciones, escritas en el núcleo del lenguaje.

Variables.- son un tipo de datos, Alfabéticas y

S “ ” 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


fi=9; for(i=0;i<n;i++) { textcolor(3); gotoxy(5,7);cprintf("VECTOR"); textcolor(i+1); gotoxy(8,fi);cprintf("%c",nombre[i]); fi=fi+1; } } void impar() { h=1; for(i=0;i<n;i++) { if(i%2==0) { vecimpar[h]=nombre[i]; h=h+1; } } fi=8; for(i=0;i<h;i++) { textcolor(3); gotoxy(15,7);cprintf("POSICIONES"); textcolor(i+1); gotoxy(20,fi);cprintf("%c",vecimpar[i]); fi=fi+1; } } void main() { do { clrscr(); borde(); textcolor(2); gotoxy(15,3);cprintf("VECTORES"); nomb(); impar(); gotoxy(5,22);cprintf("Desea repetir 1 Salir 0: ");scanf("%d",&op); }while(op==1); getch(); }


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

S “ ” impresión de las letras en posiciones impares.

Inicio del programa

Sentencia do while

Borrar pantalla Función borde

Funciones

Pausa Fin del programa pantalla


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


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

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.

#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); gotoxy(i,1);printf("±"); gotoxy(i,24);printf("±"); } for(i=2;i<=23;i++) { textcolor(6); gotoxy(1,i);printf("±"); gotoxy(80,i);printf("±"); } } void conso() { flushall(); fi=9; textcolor(5); gotoxy(5,5);cprintf("TEXTO: "); gets(tex); gotoxy(5,8);cprintf("VECTOR"); n=strlen(tex); for(i=0;i<n;i++) { textcolor(5); gotoxy(20,8);cprintf("CONSONANTES"); textcolor(i+1); gotoxy(8,fi);cprintf("%c",tex[i]);

Librerías.- colección de clases y funciones, escritas en el núcleo del lenguaje.

Variables.- son un tipo de datos, Alfabéticas y

S “ ” 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.


fi=fi+1; } fi=9; for(i=0;i<n;i++) { if(tex[i]!='a' && tex[i]!='e' && tex[i]!='i' && tex[i]!='o' && tex[i]!='u' ) { tex1[h]=tex[i]; textcolor(i+1); gotoxy(25,fi);cprintf("%c",tex1[h]); h=h+1; fi=fi+1; } } } void main() { do { clrscr(); borde(); textcolor(5); gotoxy(25,3);cprintf("VECTORES"); conso(); gotoxy(5,22);printf("Repetir el proceso 1 salir 0: ");scanf("%d",&op); }while(op==1); getch(); } CORRIDO DEL PROGRAMA

S “ ” impresión de las letras en posiciones impares.

Inicio del programa

Sentencia do while

Borrar pantalla Función borde

Funciones

Pausa Fin del programa pantalla


Programa 53 Enunciado:

Diseñe un programa utilizando vectores y funciones que me permita leer una cadena de caracteres y

presentarla de forma invertida

Codificación:


#include<stdio.h>

#include<string.h>

#include<conio.h>

int i,op,fila,a;

char nom[40];

void borde()

{

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

{

textcolor(i+1);

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

gotoxy(i,24);printf("!");

}

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

{

textcolor(i+1);

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

gotoxy(80,i);printf("!");

}

}

void inver()

{

flushall();

gotoxy(20,6);printf("Ingrese la palabra: ");gets(nom);

a=strlen(nom);

fila=9;

for(i=0;i<a;i++)

{

Librerías


Función global para el borde, e

inicio del ciclo, da color

Impresión del borde, cierre del

ciclo

Función global para el borde, e

inicio del ciclo, da color

Impresión del borde

Cierre del ciclo y de la

función

Función global e inicio

Ingreso de datos con caracteres

y almacenarían en auxiliar

C “FOR”


textcolor(i+1);

gotoxy(30,fila);cprintf("%c",nom[i]);

fila=fila+1;

}

fila=8;

for(i=a;i>=0;i--)

{

textcolor(i+1);

gotoxy(45,fila);cprintf("%c",nom[i]);

fila=fila+1;

}

}

void main()

{

do

{

clrscr();

borde();

gotoxy(32,2);printf("**Cadena de Caracteres Invertida**");

gotoxy(27,8);printf("Vector");

gotoxy(43,8);printf("Inversion");

inver();

gotoxy(12,22);printf("Digite 1 para continuar o 0 para salir : ");scanf("%d",&op);

}while(op==1);

getch();

}

Corrido:

Impresión del vector en forma

vertical

Proceso de la forma

“ ”

Impresión del nuevo vector

invertido y con color

Cierre del ciclo y de la

función

Función principal e inicio

I “ -

w ”

Limpiado de pantalla y

llamado de la función

Impresión de mensajes

Llamado de la función

Cierre del ciclo

Pausa y cierre del

programa


Análisis:

En este programa hemos utilizado la variable char para declaración con caracteres la

palabra, un g “ ”

e imprimir el en un nuevo vector todo esto se hace en una función global y al último se llama

en una función principal void main

PROGRAMA 54

ENUNCIADO

Diseñe un programa utilizando vectores y funciones que me permita leer una

cadena de caracteres y recorrer dicha cadena y encontrar solo aquellas que sean

consonantes, agruparlas y colocarlas en un nuevo vector.

ANALISIS


Utilizo 4 librerías declaro dos variables tipo carácter y 7 variables de tipo entero utilizo 3

funciones la primera para el diseño del borde en pantalla la segunda función para sacar el

proceso de encontrar las consonantes y la tercera función es la principal utilizo un do while

para repetir el proceso

CODIFICACION

#include<conio.h>

#include<stdio.h>

#include<math.h>

#include<string.h>

char cad[25],c2[25]; //DECLARACION DE VARIABLES GLOBALES ENTERAS Y DE CARACTER//

int x,li,lim,i,p,l2;

int op=1;

void borde()

{

textcolor(YELLOW);

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

{



}

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

{

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


} //FIN DEL CICLO FOR \\

} // FIN DEL CICLO DE LA FUNCION DEL BORDE //

void caracter()

{

gotoxy(5,5);printf("Cadena:");gets(cad); //IMPRIMO UN MENSAJE CON LA PALABRA CADENA\\

lim=strlen(cad);

li=7;// ACUMULADOR \\

p=0;//CONTADOR\\

FUNCIÓN BORDE

FUNCION PARA SACAR

CONSONANTES


for(i=0;i<lim;i++) // CICLO FOR PARA SACAR EL LIMITE DE LETRAS QUE QUIERO ENCONTRAR\\

{ // ABRO EL CICLO FOR\\

gotoxy(25,li);printf("%c\n",cad[i]); //IMPRIMO LA CANTIDAD DE LETRAS\\

li=li+1; //CONTADOR DEL CICLO FOR QUE SE BA IR SUMANDO DE UNO EN UNO\\

x=i; // AUXILIAR\\

(cad[i]);

if (x != 0)

{

if((cad[i] == 'a')||(cad[i] == 'e')||(cad[i] == 'i')||(cad[i] == 'o')||(cad[i] == 'u')) // CONDICIONES PARA ENCONTRAR LAS

C ONSONANTES\\

{

}

Else // CASO CONTRARIO\\

{

c2[p]=cad[i];

p=p+1; // SIRVE PARA I R DE UNO EN UNO SUMANDO \\

}

}

}

li=7; // CONTADOR \\

lim=lim-1; //LIMITE MENOS1 \\

for(i=0;i<p;i++) //

{

gotoxy(45,li);printf("%c",c2[i]);//IMPRIMO CARACTER\\

li=li+1;//LIMITE MAS UNO\\

}

}

void main() // FUNCION PRINCIPAL\\

{ // INICIO DE LA FUNCION PRINCIPAL\\

Do //INICIO DE CICLO REPETITIVO CON UN DO PARA MAS ABAJO CERRAR CON WHILE \\

{

clrscr(); //LIMPIADO DE PANTALLA\\


borde(); // FUNCION BORDE\\

caracter(); // FUNCION CARÁCTER\\

gotoxy(30,2);cprintf("======================");

gotoxy(30,3);printf("POSICIONES CONSONANTES"); //IMPRIMO LAS POSICIONES DE LAS CONSONANTES\\

gotoxy(30,4);cprintf("======================");

gotoxy(22,6);printf("PALABRA"); //IMPRIMO LA PALABRA\\

gotoxy(40,6);printf("CONSONANTE");// IMPRIMO CONSONANTES\\

gotoxy(3,23);printf("DESEA REPETIR EL PROCESO 1 O 0 PARA SALIR: ");scanf("%d",&op);

}

while(op==1); // CICLO REPETITIVO \\

getch(); // PAUSA EN EL PROGRAMA\\

} //FIN DE LA FUNCION PRINCIPAL\\

CORRIDO

Programa 55 Diseñe un programa utilizando funciones que me permita automatizar el sistema de

recaudación por concepto de matrículas a los estudiantes de la UNIANDES,

tomando en cuenta los siguientes parámetros.

Los aranceles universitarios por concepto de matrícula, están estipulados de

acuerdo a los tipos de colegios.

Si es particular paga 250,00

o Servicio médico que representa el 9% del valor de la matrícula

o Servicio de internet que el 10% del valor de la matrícula


o Servicio de canchas deportivas y servicios adicionales 12% del valor de la

matrícula

o Visualice los valores parciales y totales del costo de la matrícula.

Si es fiscomisional paga 180,00




matrícula

Si es fiscal paga 120,00




matrícula

o Visualice los valores parciales y totales del costo de la matrícula.

Todos pagan por derecho de carnet usd. 5,00

Visualice el número de estudiantes matriculados y el valor total recaudado por

concepto de matriculas

El proceso se repite tantas veces como el usuario lo decida

Se presenta el diseño del borde.

Programa 56 Enunciado

Diseñe un programa utilizando vectores y funciones que me permita Ingresar n

elementos entre 3 y 23 en las posiciones impares del vector y las posiciones pares

se generan con cualquier factor ingresado desde teclado, recorra el vector y

encuentre todos aquellos valores que sean números primos y asignarlos a un nuevo

vector, presente el vector resultante ordenado en forma ascendente y descendente.

Análisis

1. Codificamos el borde dentro de una funciones

2. Dentro de otra funciones ingresamos un límite y un factor

3. Si la posiciones es par debemos condicionar el valor ingresado entre 3 y 23

4. Si la posiciones es impar realizamos el proceso para que se genere el factor

5. Realizamos otra función para imprimir los números que sean únicamente

primos

6. Utilizamos un for para verificar si los datos son primos, de ser así se asignara

dicho valor a un vector

7. Utilizamos otra función para ordenar de forma ascendente los valores

asignados al vector de números primos


8. De igual manera utilizamos una función para ordenar de forma descendente

los valores asignados al vector de los números primos.

9. Abrimos la función del programa principal

10. Llamamos las funciones previamente codificadas

Documentación

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

Librerías

Declaración de Variables int

Inicio de función borde

Lazo For

Fin de función

Función de ingreso

Ingresos e impresiones

Inicializaciones

Lazo For


} } 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++) { gotoxy(38,10);printf("Ascendente"); gotoxy(40,fila);printf("%d",vec[i]); fila=fila+1; } }//cierre

Fin de función

Funciones primos

Inicialización variables

Lazo For

Condición If

Fin función

Función Ascendente

Lazo For

Fin de función


void descendente() { for(i=1;i<lim2;i++) { for(j=1;j<lim2;j++) { if(vec[i]>vec[j]) { aux=vec[i]; vec[i]=vec[j]; vec[j]=aux; } } } fila=11; for(i=1;i<lim2;i++) { gotoxy(58,10);printf("Descendente"); gotoxy(65,fila);printf("%d",vec[i]); fila=fila+1; } }//cierre void main() { do { clrscr(); borde(); ingreso(); primos(); ascendente(); descendente(); getch(); gotoxy(10,22);printf("Presione 1/0>> ");scanf("%d",&op); }while(op==1); }

Corrido

Función descendente

Lazo for

Fin de función

Función principal

Llamado de funciones

Lazo Do While

Fin de función


Programa 57

1. ENUNCIADO:

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.

2. ANÁLISIS:

En este programa utilizaremos funciones tanto para el borde como para ingresar y

presentar los datos de nuestra matriz, esencialmente la utilización de ciclos FOR

para que permita ingresar los datos de nuestra matriz, imprimimos resultados y

utilizamos un DO-WHILE para que el programa se repita n veces quiera el usuario.

3. DOCUMENTACION:

#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++) { gotoxy(k,2);printf("-"); gotoxy(k,24);printf("-"); } for(k=2;k<=24;k++) { gotoxy(2,k);printf("-"); gotoxy(80,k);printf("-"); } } void ing(int datos) { col=10; fila=8; for(i=1;i<=limite;i++) { for(j=1;j<=limite;j++) { gotoxy(col,fila); scanf("%d",&matriz1[i][j]); col=col+5; } col=10; fila=fila+1; } } void sal(int sali) { fila=8; col=40; for(i=1;i<=limite; i++) { for(j=1;j<=limite;j++) { gotoxy(col,fila); printf("%d",matriz1[i][j]); col=col+5; } col=40; fila=fila+1; } } void main() { do {


Función para el diseño del

borde

Función para el ingreso de los

datos de la matriz utilizando

ciclos FOR

Función para la impresión de

nuestra matriz utilizando ciclos

FOR

Cuerpo principal del

programa

Ciclo DO-while para repetir n veces


clrscr(); borde(); gotoxy(3,3); printf("Ingrese un límite: "); scanf("%d",&limite); ing(datos); sal(sali); gotoxy(4,22); printf("NUEVO 1 SALIR 0: "); scanf("%d",&op); } while(op==1); getch(); }

4. CORRIDO DEL PROGRAMA:

Programa 58

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

ANALISIS

Este programa me permite ingresar una matriz de cualquier orden y se imprime los factores ingresados en toda la matriz.

Ingresamos la librerías y las variables globales abrimos una función para el borde e ingresamos textcolor(YELLOW); para escoger el color mediente lazos for hacemos el proceso del borde y cerramos el mismo, abrimos la función del programa ingresamos en una variable para que se almacene el factor, también se ingresa las filas y columnas de la matriz, sumamos el factor para la variable ingresada ubicamos las posiciones de la matriz y cerramos el programa. Abrimos la función para llamar al proceso ingreso un lazo repetitivo,

Blanqueo de

Llamado de la función del

Llamado de las funciones de la matriz

Ingreso del límite de

Ciclo DO-while para repetir n

veces

Pausar


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

#include<stdio.h> #include<conio.h> LIBRERIAS #include<ctype.h> int i,j,m,matriz[5][5],columna,fila,limite,datos,factor,a,op; VARIABLES GLOBALES void borde(int datos) SE ABRE LA FUNCION DEL BORDE { textcolor(YELLOW); ESCOGER EL COLOR for(i=1;i<=80;i++) { gotoxy(i,1);cprintf("*"); gotoxy(i,24);cprintf("*"); } PROCESO DEL BORDE for(i=1;i<=24;i++) { gotoxy(1,i);cprintf("*"); gotoxy(80,i);cprintf("*"); } } SE CIERRA LA FUNCION void programa(int datos) FUNCION DEL PROGRAMA { SE ABRE LA FUNCION a=0; gotoxy(33,3);cprintf("MATRIZ FACTOR"); gotoxy(8,5);cprintf("Limite: ");scanf("%d",&datos); ENUNCIADOS gotoxy(8,6);cprintf("Factor: ");scanf("%d",&factor); columna=10; fila=10; for(i=1;i<=datos; i++) PROCESO DE LA MATRIZ { for(j=1;j<=datos; j++) { gotoxy(8,8);cprintf("Matriz ingreso"); a=a+factor; matriz[i][j]=a; gotoxy(columna,fila);printf("%d",matriz[i][j]); columna=columna+4; PROCESO DEL FACTOR } columna=10; fila=fila+2;


} a=0; columna=50; fila=10; for(i=1;i<=datos; i++) { for(j=1;j<=datos; j++) { gotoxy(45,8);cprintf("Matriz resultante"); a=a+factor; matriz[i][j]=a; PROCESO PARA COPIAR ALADO gotoxy(columna,fila);printf("%d",matriz[i][j]); EL FACTOR columna=columna+4; } columna=50; fila=fila+2; } } SE CIERRA LA FUNCION void main () SE ABRE LA FUNCION PARA LLAMAR AL PROGRAMA { do { SE ABRE EL LAZO REPETITIVO clrscr (); LIMPIADOR DE PANTALLA borde(datos); programa(datos); LLAMA A LAS FUNCIONES gotoxy(3,23);cprintf("DESEA REPETIR PRESIONE 1 O 0 PARA SALIR: ");scanf("%d",&op); } SE CIERRA EL LAZO REPETITIVO while(op==1); getch(); PARA QUE NO EXISTA ECO } SE CIERRA EL PROGRMA


Programa 59

Diseñe un programa utilizando funciones y matrices que me permita Imprimir una matriz cuadrática de ceros excepto la diagonal principal.

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

#include<conio.h> #include<stdio.h> LIBRERIAS #include<ctype.h> int op=1,limite,fila=7,columna=13,i,j; INGRESAMOS VARIABLES GLOBALES int matriz[10][10],datos; void borde() FUNCION DEL BORDE { textcolor(YELLOW); INGRESAR COLOR for(i=1;i<=80;i++) { gotoxy(i,1);cprintf("*"); gotoxy(i,24);cprintf("*"); } for(i=1;i<=24;i++) PROCESO DEL BORDE { gotoxy(1,i);cprintf("*"); gotoxy(80,i);cprintf("*"); } } CIERRO LA FUNCION void programa(int datos) FUNCION DEL PROGRAMA { ABRIR LA FUNCION gotoxy(3,5);cprintf("Limite: ");cscanf("%d",&limite); INGRESAR UN LIMITE for(i=1;i<=limite;i++) { ORDENAR LA MATRIZ


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


Programa 60 Diseñe un programa utilizando matrices y funciones que me permita llenar una

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.

Análisis

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.

Documentación

#include<conio.h> #include<stdio.h> int op,i,j,fi,c,n,ma[50][50],f,cf,fac; void borde() { for(i=1;i<=79;i++) { gotoxy(80,1);printf("»"); gotoxy(1,1);printf("É"); gotoxy(i,1);printf("Í"); gotoxy(i,24);printf("Í"); } for(i=2;i<=23;i++) { gotoxy(1,24);printf("È"); gotoxy(80,24);printf("¼"); gotoxy(1,i);printf("º"); gotoxy(80,i);printf("º"); } } void presen(int m) { c=15; fi=5; cf=0; gotoxy(15,4);printf("Ingrese factor: ");scanf("%d",&f); 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]);

librerias

Función borde

Ingreso de la matriz


c=c+3; } else { ma[i][j]=0; gotoxy(c,fi);printf("%d",ma[i][j]); c=c+3; } } c=15; fi=fi+1; } } void diago(int m) { c=45; fi=5; cf=0; 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; } } fi=fi+1; } } void diagosec(int m) { c=45; fi=5; fac=1; for(i=1;i<=n;i++) { for(j=m;j>=1;j--) { if(i==j) { fac=fac*j; ma[i][j]=fac; gotoxy(c,fi);printf("%d",ma[i][j]); c=c+3; } c=c+3;

Contador

Ciclo

fortador

Ciclo

fortador

Ierre de los ciclofuncions for

Inicio de otra


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); gotoxy(15,22);printf("Desea salir 1/0: ");scanf("%d",&op); }while(op==1); getch(); } Corrido

Imprecion


Programa 61 Diseñe un programa utilizando funciones y matrices que me permita Generar una

matriz con la serie del fibonasi, encontrar los datos de sus diagonales visualizarlos

en forma de equiz, asignar estos datos a un vector resultante ordenado en forma

ascendente y descendente.

Análisis

Para este programa utilizamos funciones para llamar al procedimiento para realizar

el ejercicio también necesitamos matrices, variables globales para generar poder

realizar los respectivos procedimientos para generar la serie del fibonasi y asi

proseguir a llamar a las distintas funciones en donde se visualice la matriz las

diagonales otra para ordenar ascendentemente y otra para ordenar

descendentemente.

Documentación

#include<conio.h>

#include<stdio.h>

int fil, col, aux, i, j, mat[10][10], vect[10], lim, op, a, b, c, h;

void bdob()

{

int i;

clrscr();



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

{



}



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

{


Librerías

Función global para el

borde




}

}

void diag()

{

col=5;

fil=8;

a=1;

b=0;

c=0;

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

{

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

{

c=a+b;

a=b;

b=c;

mat[i][j]=c;

gotoxy(col,fil);printf("%d",mat[i][j]);

col=col+4;

}

col=5;

fil=fil+3;

}

}

void dprinc()

{

col=21;

fil=8;

Inicio de la función para

determinar las

Condición para calcular las

diagonales

Proceso para calcular la

serie del fibonasi


calcular la diagonal

principal


h=1;

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

{

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

{

if(i==j)

{

vect[h]=mat[i][j];

h=h+1;


col=col+4;

}

}

fil=fil+3;

}

}

void dsec()

{

col=28;

fil=8;

j=lim;

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

{

vect[h]=mat[i][j];

h=h+1;


j=j-1;

col=col-4;

fil=fil+3;

}

Condición para calcular la

diagonal

Función para calcular la

diagonal secundaria

Imprimimos la matriz


}

void diag_vect()

{

fil=8;

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

{

gotoxy(41,fil);printf("%d",vect[i]);

fil=fil+2;

}

}

void orden()

{

fil=8;

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

{

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

{

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

{

aux=vect[i];

vect[i]=vect[j];

vect[j]=aux;

}

}

}

fil=8;

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

{


fil=fil+2;

Función para ordenar las

diagonales.

Calculamos el vector

descendente


}

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

{

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

{

if(vect[i]>vect[j])

{

aux=vect[i];

vect[i]=vect[j];

vect[j]=aux;

}

}

}

fil=8;

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

{


fil=fil+2;

}

}

void main()

{

do

{

clrscr();

bdob();

gotoxy(34,2);printf("<<MATRICES>>");

gotoxy(5,4);printf("Ingrese el limite>> ");scanf("%d",&lim);

gotoxy(4,6);printf("<<MATRIZ>>");

gotoxy(18,6);printf("<<Diagonales>>");

Función donde a

proseguimos a imprimir

los datos

Proceso para ordenar


gotoxy(34,6);printf("<<Vector_Diag>>");

gotoxy(50,6);printf("<<Ascendente>>");

gotoxy(65,6);printf("<<Descendente>>");

diag();

dprinc();

dsec();

diag_vect();

orden();

gotoxy(3,22);printf("Presione 1 para volver a repetir el proceso o 0 para finalizar>>

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

}

while(op==1);

getch();

}

Corrido.

Pedimos los respectivos

datos.


Programa 62 Diseñe un programa utilizando matrices y funciones que me permita generar una

matriz con números pares, a excepción de sus diagonales, las mismas que se llenan

con números impares, recorra la matriz y encuentre los dtos de sus diagonales y

guarderlas en vector.

Análisis

Primero ingresamos las librerías que vamos a utilizar en este programa en este caso

son las dos principales la STDIO.H Y LA CONIO.H, después como es un programa

con funciones declaramos las variables que vamos a utilizar globalmente

proseguimos a nombrar una función llamada borde para que nuestro programa se

visualice con un borde y otra función en donde realicemos los cálculos de la matriz

para finalizar realizamos el programa principal con un VOID MAIN y proseguimos a

llamar cada función e imprimimos.

CODIGO

#include<stdio.h> #include<conio.h> int a,i,j,lim,imp,b,matriz[10][10],col,fil,op; void borde() { for(i=1;i<=80;i++) { gotoxy(i,1);printf("+"); gotoxy(i,24);printf("+"); } for(i=1;i<=24;i++) { gotoxy(1,i);printf("+"); gotoxy(80,i);printf("+"); } } void mat() { a=2; b=1; col=5; fil=10; for(i=0;i<lim;i++) { for(j=0;j<lim;j++) { if(i==j || j==(lim-1)-i) { matriz[i][j]=b; b=b+2; }

Librerías que vamos a utilizar en el

Declaramos la variable

global

Realizamos la función para que se

pueda realizar un borde en nuestro

Inicio de la función para realizar el calculo

de la matriz

Calculamos las diagonales de la

matriz con numeros impares y

rellenamos la matriz con numeros

pares


else{ matriz[i][j]=a; a=a+2; } gotoxy(col,fil);printf("%d",matriz[i][j]); col=col+4; } fil=fil+2; col=5; } } void main() { do { clrscr(); borde(); gotoxy(3,4);printf("Ingrese el limite > "); scanf("%d",&lim); mat(); gotoxy(3,22); printf("1 continuar 0 salir > "); scanf("%d",&op); } while(op==1); getch(); }

Corridor.

En esta función ya

proseguimos a

llamar a las otras

funciones e


BIBLIOGRAFIA:

http://ejercicioscpp.blogspot.com/2012 /09/tipos-de-datos-en-c.html

http://www.nachocabanes.com/tutors/teoc-lebron.pdf

http://utch2009.files.wordpress.com/2010/02/manual-de-turbo-c.pdf

http://www.taringa.net/posts/ebooks-tutoriales/14600832/Funciones-y-sentencias-de-programacion-en-C.html

http://blog.espol.edu.ec/programando/sentencia-repetitiva-for-lenguaje-c/

http://logpracticas2013.blogspot.com/2013/04/c-introduccion-de-datos-contadores-y.html

http://www.programacionfacil.com/cpp/funciones.

http://books.google.es/books?hl=es&lr=&id=n9VEG2Gp5pkC&oi=fnd&pg=PR17&dq=C%2B%2B+TUTORIAL&ots=Rem4npbdOQ&sig=Tev8U08QBBkpEENdsFAUs4L1aRs#v=onepage&q=C%2B%2B%20TUTORIAL&f=false

http://www.flipsnack.com/9A6E898F8D6/fdnfbfi9

http://ejercicioscpp.blogspot.com/2012

http://www.nachocabanes.com/tutors/teoc-lebron.pdf



http://blog.espol.edu.ec/programando/sentencia-repetitiva-for-lenguaje-c/



http://www.programacionfacil.com/cpp/funciones




c+++

Documents

Transcript of c+++