Post on 10-Apr-2016
description
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
C++ - Ashqui Israel 4
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
C++ - Ashqui Israel 5
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
PROGRAMA N.-13.- Diseñe un programa que me permita visualizar la serie de los
números pares y los impares que existen hasta el número límite ingresado desde teclado.
.................................................................................................................................................. 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
C++ - Ashqui Israel 6
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
C++ - Ashqui Israel 7
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
C++ - Ashqui Israel 8
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
C++ - Ashqui Israel 9
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
C++ - Ashqui Israel 10
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.
C++ - Ashqui Israel 11
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,
C++ - Ashqui Israel 12
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
C++ - Ashqui Israel 13
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
Descripción Número de bytes típico
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
Descripción Número de bytes típico
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
Descripción Número de bytes típico
Rango
wchar_t
Carácter Unicode 2 0 a 65535
C++ - Ashqui Israel 14
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
C++ - Ashqui Israel 15
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 */
C++ - Ashqui Israel 16
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í:
C++ - Ashqui Israel 17
#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.
C++ - Ashqui Israel 18
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.
C++ - Ashqui Israel 19
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 * /
C++ - Ashqui Israel 20
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:
C++ - Ashqui Israel 21
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(); } }
C++ - Ashqui Israel 22
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.
C++ - Ashqui Israel 23
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>
C++ - Ashqui Israel 24
#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() {
C++ - Ashqui Israel 25
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;
C++ - Ashqui Israel 26
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) {
C++ - Ashqui Israel 27
//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.
C++ - Ashqui Israel 28
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;
C++ - Ashqui Israel 29
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.
C++ - Ashqui Israel 30
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];
C++ - Ashqui Israel 31
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.
C++ - Ashqui Israel 32
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() {
C++ - Ashqui Israel 33
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
C++ - Ashqui Israel 34
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.
C++ - Ashqui Israel 35
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
C++ - Ashqui Israel 36
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].
C++ - Ashqui Israel 37
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;
C++ - Ashqui Israel 38
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--}
C++ - Ashqui Israel 39
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
C++ - Ashqui Israel 40
> 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
C++ - Ashqui Israel 41
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
Es una condición donde se
ejecuta solamente si la
expresión es verdadera.
C++ - Ashqui Israel 42
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
Las librerías sirven
para llamar a las
funciones que se
desea
Funciones estándar
C++ - Ashqui Israel 43
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("*");
gotoxy(70,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
C++ - Ashqui Israel 44
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.
C++ - Ashqui Israel 45
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:
Espera a que se presione
cualquier otra tecla para
finalizar
Cierra el programa }
Impresión de
datos
C++ - Ashqui Israel 46
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
C++ - Ashqui Israel 47
#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
Este es mientas cumpla
la condición
Es para la ubicación
de las filas y las
Imprime los valores o
expresiones que se le
Lee el dato que se le
da
Es una condición donde se
ejecuta solamente si la
expresión es verdadera.
Es el que realiza una
declaración
Manejo de cadenas
C++ - Ashqui Israel 48
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
C++ - Ashqui Israel 49
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.
Espera a que se presione
cualquier otra tecla para
finalizar
Cierra el
programa
C++ - Ashqui Israel 50
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(36,5);printf(" ");
gotoxy(10,5); printf("INGRESE EL PRIMER NUMERO: ");
scanf("%d",&a);
}
gotoxy(37,7);printf(" ");
Es el inicio de la
ejecución del
Sirve para
declarar las
Limpia la pantalla
Es para la ubicación
de las filas y las
Es para abrir el
programa
Imprime los valores o
expresiones que se le
Lee el dato que se le
da
Las librerías sirven
para llamar a las
funciones que se desea
Manejo de cadenas
C++ - Ashqui Israel 51
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
Las librerías sirven
para llamar a las
funciones que se desea
Espera a que se presione
cualquier otra tecla para
finalizar
Cierra el programa
C++ - Ashqui Israel 52
#include<string.h>
void main()
{
int a, b, suma, op;
do
{
clrscr();
gotoxy(15,3);
printf("SUMA DE DOS NUMEROS");
do
{
gotoxy(36,5);printf(" ");
gotoxy(10,5); printf("INGRESE EL PRIMER NUMERO: ");
scanf("%d",&a);
Es el inicio de la
ejecución
Sirve para
declarar las
Es para que cumpla una
condición y tiene retorno
Limpia la pantalla
Es para la ubicación
de las filas y las
Es para abrir el
programa
Imprime los valores o
expresiones que se le
Lee el dato que se le
da
Manejo de cadenas
C++ - Ashqui Israel 53
}
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:
Este es mientas cumpla
la condición
Es para que cumpla una
condición y tiene
Espera a que se presione
cualquier otra tecla para
finalizar
Cierra el programa
C++ - Ashqui Israel 54
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
C++ - Ashqui Israel 55
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)
{
Cargar o inicializar variable de condición
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
C++ - Ashqui Israel 56
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
C++ - Ashqui Israel 57
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++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
} Diseño de la estructura del margen
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
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");
C++ - Ashqui Israel 58
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
C++ - Ashqui Israel 59
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++ - Ashqui Israel 60
{
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
{
gotoxy(36,fla);printf(" ");
gotoxy(36,fla);scanf("%f",&n2);
}while(n2>10 || n2<1);
do
{
gotoxy(45,fla);printf(" ");
gotoxy(45,fla);scanf("%f",&n3);
}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
que debe estar entre 1
hasta 10
Ingresa la tercera nota
Aquí cierra la condición
que debe estar entre 1
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
Retorna el carácter leído desde
teclado Cierra el programa
C++ - Ashqui Israel 61
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
C++ - Ashqui Israel 62
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
Cargar o inicializar variable de condición
Impresión de mensaje
Imprime el mensaje
Ingresa datos
Imprime el mensaje
Da posicionamiento en donde desee aparecer el
mensaje
Diseño del programa
C++ - Ashqui Israel 63
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
C++ - Ashqui Israel 64
}
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);
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);
}
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);
Realiza el proceso del programa
Imprime resultados
Imprime resultados
Realiza el proceso del programa
C++ - Ashqui Israel 65
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);
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
C++ - Ashqui Israel 66
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
C++ - Ashqui Israel 67
{
int n,fila,i,op=1;
do
{
clrscr();
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
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
Retorna el carácter leído desde
Cierra el programa
C++ - Ashqui Israel 68
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.
C++ - Ashqui Israel 69
Codificación:
#include<stdio.h>
#include<conio.h>
main()
{
int i;
clrscr();
for(i=1;i<=80;i++)
{
gotoxy(i,1);
printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
getch();
Las librerías sirven
para llamar a las
funciones que se desea
Sirve para declarar
las variables
Es el inicio de la
ejecución del
Limpia la pantalla
Inicio de un ciclo
con un límite
Es para la ubicación
de las filas y las
Imprime los valores o
expresiones que se le
Inicio de un ciclo
con un límite
Espera a que se presione
cualquier otra tecla para
finalizar
C++ - Ashqui Israel 70
}
Corrido:
PROGRAMA N.-12.- Diseñe un programa que me permita visualizar la serie de los
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
Las librerías sirven
para llamar a las
funciones que se desea
Es el inicio de la
ejecución del
C++ - Ashqui Israel 71
int i;
clrscr();
for(i=1;i<=80;i++)
{
gotoxy(i,1);
printf("*");
gotoxy(i,24);printf("*");
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
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
Es para la ubicación
de las filas y las
Imprime los valores o
expresiones que se le
Inicio de un ciclo
con un límite
Acumulador para que
vaya dando espacios
Mensaje para continuar o
terminar el programa
C++ - Ashqui Israel 72
}
While(op==1)
getch();
}
3.- CORRIDO
PROGRAMA N.-13.- Diseñe un programa que me permita visualizar la serie de los
números pares y los impares que existen hasta el número límite ingresado desde teclado.
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
C++ - Ashqui Israel 73
void main()
{
int limite,i,fla,op; 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(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
C++ - Ashqui Israel 74
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
C++ - Ashqui Israel 75
Codificación:
#include<conio.h>
#include<stdio.h>
void main()
{
int i,f,l,d,op;
do
{
clrscr();
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
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
C++ - Ashqui Israel 76
}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
C++ - Ashqui Israel 77
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 *
gotoxy(i,24);printf("*");
} finalize el for
for(i=1;i<=24;i++) inicializa el for
{ llave de inicio del for
gotoxy(1,i);printf("*");
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
C++ - Ashqui Israel 78
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
C++ - Ashqui Israel 79
clrscr(); borrado de pantalla
gotoxy(30,3);printf("SERIE PRIMOS/IMPARES"); inpresion del titulo
for(i=1;i<=80;i++) inicia for
{ llave de inicio del for
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*"); impresion de *
} cierre del ciclo
for(i=1;i<=24;i++) inico condicion
{ inicio
gotoxy(1,i);printf("*");
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
{ llave de inicio del for
res=i%j; proceso
3.- Corrido de programa
4.- Análisis del Programa:
C++ - Ashqui Israel 80
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++)
{
gotoxy(1,i);printf("*");
gotoxy(79,i);printf("*");
}
for(i=1;i<=80;i++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
gotoxy(29,2);printf("NUMEROS PRIMOS");
gotoxy(6,4);printf("INGRESE EL LIMITE : ");scanf("%d",<);
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
C++ - Ashqui Israel 81
} 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,24);printf("*");
gotoxy(i,1);printf("*"); proceso de impresion de borde
}
for(i=1;i<=24;i++)
{
C++ - Ashqui Israel 82
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
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.
C++ - Ashqui Israel 83
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
C++ - Ashqui Israel 84
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
C++ - Ashqui Israel 85
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
C++ - Ashqui Israel 86
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;
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
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
C++ - Ashqui Israel 87
b=0;
col=5;
num=-1;
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(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
C++ - Ashqui Israel 88
}
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
Las librerías sirven para llamar
a las funciones q se desee.
Función específicamente para el borde
Variable para el margen de pantalla.
C++ - Ashqui Israel 89
for(i=1;i<=80;i++)
{
gotoxy(i,1); printf("*");
gotoxy(i,24); printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i); printf("*");
gotoxy(80,i); printf("*");
}
}
void main()
{
int 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
Es el inicio de la ejecución del
Sirve para declarar variables
Variable para trabajar con decimales
Llama al borde sirve para no volver a repetir el proceso
de este.
Cumple una función que tiene retorno
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
C++ - Ashqui Israel 90
gotoxy(20,3); printf("1.-SUMA");
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();
gotoxy(20,3); printf("2.-RESTA");
gotoxy(10,5); printf("INGRESE EL PRIMER VALOR==>"); scanf("%d",&a);
gotoxy(10,7); printf("INGRESE EL SEGUNDO VALOR==>"); scanf("%d",&b);
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");
gotoxy(10,5); printf("INGRESE EL PRIMER VALOR==>"); scanf("%d",&a);
gotoxy(10,7); printf("INGRESE EL SEGUNDO VALOR==>"); scanf("%d",&b);
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
C++ - Ashqui Israel 91
case 4:
clrscr();
borde();
gotoxy(20,3); printf("4.-DIVISION");
gotoxy(10,5); printf("INGRESE EL PRIMER VALOR==>"); scanf("%d",&a);
gotoxy(10,7); printf("INGRESE EL SEGUNDO VALOR==>"); scanf("%d",&b);
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
C++ - Ashqui Israel 92
CORRID
C++ - Ashqui Israel 93
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++)
{
gotoxy(i,1); printf("*");
gotoxy(i,24); printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i); printf("*");
gotoxy(80,i); printf("*");
}
}
void main()
{
int 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;
Las librerías sirven para llamar
a las funciones q se desee.
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
Es el inicio de la ejecución del
Limpia
Lama
Indicamos el valor de
Cumple una función que tiene retorno
C++ - Ashqui Israel 94
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,5); printf("***AREA***");
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
C++ - Ashqui Israel 95
gotoxy(10,11); printf("EL AREA ES==>%d",ar);
gotoxy(10,13); printf("***PERIMETRO***");
gotoxy(10,15); printf("EL PERIMETRO ES==>%d",per);
break;
case 3:
clrscr();
borde();
gotoxy(20,3); printf("3.-AREA Y PERIMETRO DEL CIRCULO");
gotoxy(10,5); printf("***AREA***");
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,11); printf("***PERIMETRO***");
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,5); printf("***AREA***");
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,11); printf("EL AREA ES==>%d",ar);
gotoxy(10,13); printf("***PERIMETRO***");
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
C++ - Ashqui Israel 96
gotoxy(10,17); printf("EL PERIMETRO ES==>%d",per);
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
C++ - Ashqui Israel 97
C++ - Ashqui Israel 98
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++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}
void main ()
{
int op,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
C++ - Ashqui Israel 99
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(48,8);printf(" ---");
gotoxy(38,9);printf(" RESPUESTA : %f",h);
break;
case 3 :
clrscr();
borde();
gotoxy(35,2);printf("***MULTIPLICACION***");
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;
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
C++ - Ashqui Israel 100
gotoxy(48,8);printf(" ---");
gotoxy(38,9);printf(" RESPUESTA : %f",h);
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: ");
gotoxy(25,6);printf("INGRESE EL PRIMER VALOR : ");scanf("%f",&b);
gotoxy(25,7);printf("INGRESE EL SEGUNDO VALOR: ");scanf("%f",&a);
}while(a>b);
e=b/a;
gotoxy(48,8);printf(" ---");
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);
gotoxy(48,8);printf(" ---");
gotoxy(33,9);printf(" RESPUESTA : %f",h);
break;
case 6 :
clrscr();
borde();
gotoxy(35,2);printf("***RADICACION***");
gotoxy(25,6);printf("INGRESE EL VALOR : ");scanf("%f",&b);
h=sqrt(b);
gotoxy(48,7);printf(" ---");
gotoxy(30,8);printf(" RESPUESTA : %f",h);
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
C++ - Ashqui Israel 101
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.
C++ - Ashqui Israel 102
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++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
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
Declaración de variables
Impresión del
menú
C++ - Ashqui Israel 103
gotoxy(25,9);printf("3.- METROS");
gotoxy(25,10);printf("4.- CENTIMETROS");
gotoxy(25,11);printf("5.- MILIMETROS ");
gotoxy(25,12);printf("6.- SALIR");
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***");
gotoxy(25,3);printf("INGRESE EL PRIMER VALOR : ");scanf("%f",&b);
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***");
gotoxy(25,3);printf("INGRESE EL VALOR : ");scanf("%f",&b);
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);
gotoxy(30,7);printf(" M : %f",m);
gotoxy(30,8);printf(" cm : %f",cm);
gotoxy(30,9);printf(" mm : %f",mm);
break;
case 3 :
clrscr();
borde();
gotoxy(28,2);printf("***VALOR EN METROS***");
gotoxy(25,3);printf("INGRESE EL PRIMER VALOR : ");scanf("%f",&b);
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
C++ - Ashqui Israel 104
dm=b*0.1;
cm=b*100;
mm=b*1000;
gotoxy(30,5);printf(" KM : %f",k);
gotoxy(30,6);printf(" DM : %f",dm);
gotoxy(30,7);printf(" M : %f",b);
gotoxy(30,8);printf(" cm : %f",cm);
gotoxy(30,9);printf(" mm : %f",mm);
break;
case 4 :
clrscr();
borde();
gotoxy(28,2);printf("***VALOR EN CENTIMETROS***");
gotoxy(25,3);printf("INGRESE EL PRIMER VALOR : ");scanf("%f",&b);
k=b*0.0001;
dm=b*0.01;
m=b/100;
mm=b*10;
gotoxy(30,5);printf(" KM : %f",k);
gotoxy(30,6);printf(" DM : %f",dm);
gotoxy(30,7);printf(" M : %f",m);
gotoxy(30,8);printf(" cm : %f",b);
gotoxy(30,9);printf(" mm : %f",mm);
break;
case 5 :
clrscr();
borde();
gotoxy(28,2);printf("***VALOR EN CENTIMETROS***");
gotoxy(25,3);printf("INGRESE EL PRIMER VALOR : ");scanf("%f",&b);
k=b*0.00001;
dm=b*0.001;
m=b/1000;
mm=b*100;
gotoxy(30,5);printf(" KM : %f",k);
gotoxy(30,6);printf(" DM : %f",dm);
gotoxy(30,7);printf(" M : %f",m);
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
C++ - Ashqui Israel 105
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
C++ - Ashqui Israel 106
#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++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}
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 *
C++ - Ashqui Israel 107
{
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,7);printf("4.- SALIR");
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");
gotoxy(28,4);printf("INGRESE UN NUMERO : ");scanf("%d",&n);
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.
Case 2 borrado de pantalla
Función borde impresión
del título lectura de n
llamado a la función.
C++ - Ashqui Israel 108
break;
case 3 :
clrscr();
borde();
gotoxy(28,2);printf("VERIFICACION DE PRIMOS");
gotoxy(28,4);printf("INGRESE UN NUMERO : ");scanf("%d",&n);
numpri(np);
break;
case 4:
exit(0); // sale del programa
break; // finalize el switch
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
Case 3 borrado de pantalla
Función borde impresión
del título lectura de n
llamado a la función.
C++ - Ashqui Israel 109
Codificado:
#include<conio.h>
#include<stdio.h>
int i; //declaración de variables
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 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 *
C++ - Ashqui Israel 110
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++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}
void numeros (int 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
C++ - Ashqui Israel 111
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
C++ - Ashqui Israel 112
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
C++ - Ashqui Israel 113
#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++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("±");
gotoxy(80,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
tv=venta*0.08; //proceso
} //termina if
else //caso contrario
{ //llave de inicio
tv=venta*0.11; //proceso
}
} 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 *
C++ - Ashqui Israel 114
{
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,6);printf("2.Vendedor 2");
gotoxy(10,7);printf("3.Vendedor 3");
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
C++ - Ashqui Israel 115
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 3:
clrscr();
borde();
cont1=cont1+1;
gotoxy(10,5);printf("Vendedor 3: ");scanf("%f",&venta);
v1(venta);
contv=contv+tv;
val=val+venta;
gotoxy(15,20);printf("Desea insertar otra venta 1/0: ");scanf("%d",&op1);
}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
exit(0); // sale del programa
break; // finalize el switch
}
gotoxy(15,22);printf("Desea salir 1/0: ");scanf("%d",&op);
}while(op==1); // evalua la opcion escojida
getch();
}
Corrido:
Case 3
limpia
pantalla
llama
borde
Contadore
s
Impresión de
resultados
C++ - Ashqui Israel 116
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++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}
void decis (int consumo2)
{
if(consumo2<30)
Activación de librerias
Función borde
C++ - Ashqui Israel 117
{
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
C++ - Ashqui Israel 118
}
CORRIDO:
C++ - Ashqui Israel 119
ELEMENTO 3
http://www.youtube.com/watch?v=sMy7EbJlhp4
C++ - Ashqui Israel 120
ELEMENTO 4
Funciones vectores matrices
C++ - Ashqui Israel 121
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++)
{
gotoxy(1,i);printf("±");
gotoxy(80,i);printf("±");
}
}
void numero()
{
do
{
gotoxy(24,4);printf(" ");
gotoxy(15,4);printf("Numero 1; ");scanf("%d",&a);
}
while(a>64 || a<4);
do
{
gotoxy(24,5);printf(" ");
gotoxy(15,5);printf("Numero 2: ");scanf("%d",&b);
}
while(b>64 || b<4);
LIBRERIA
Declaración de variables
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
C++ - Ashqui Israel 122
do
{
gotoxy(24,6);printf(" ");
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.
C++ - Ashqui Israel 123
void main()
{
do
{
clrscr();
borde();
numero();
orden();
gotoxy(15,22);printf("Desea salir 1/0: ");scanf("%d",&op);
}
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
C++ - Ashqui Israel 124
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++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}
void perfecto(int l)
{
r=pow(dos,ex);
s=pow(dos,ex2);
v=r*(s-1);
gotoxy(7,8);printf("%d",v);
for(i=1;i<=l-1;i+
{
a=pow(dos,expo2);
b=pow(dos,expo3);
expo2=expo2+2;
expo3=expo3+2;
c=a*(b-1);
gotoxy(7,f);printf("%d",c);
LIBRERIA
Declaración de variables
Inicio de la función
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
C++ - Ashqui Israel 125
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(50,22);printf(" ");
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
Declaración de variables
Inicio de la función principal
C++ - Ashqui Israel 126
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
C++ - Ashqui Israel 127
} // 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
C++ - Ashqui Israel 128
{ // 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
C++ - Ashqui Israel 129
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
C++ - Ashqui Israel 130
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++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}
void edad()
{
do
{
gotoxy(11,6);printf(" ");
Función borde
librerias
C++ - Ashqui Israel 131
gotoxy(11,6);scanf("%d",&dn);
}
while(dn<1 || dn>30);
gotoxy(13,6);printf("/");
do
{
gotoxy(14,6);printf(" ");
gotoxy(14,6);scanf("%d",&mn);
}
while(mn<1 || mn>12);
gotoxy(16,6);printf("/");
gotoxy(17,6);scanf("%d",&an);
gotoxy(5,8);printf("Ingrese la fecha actual dd/mm/aa>> ");
do
{
gotoxy(11,9);printf(" ");
gotoxy(11,9);scanf("%d",&d);
}
while(d<1 || d>30);
gotoxy(13,9);printf("/");
do
{
gotoxy(14,9);printf(" ");
gotoxy(14,9);scanf("%d",&m);
}
while(m<1 || m>12);
gotoxy(16,9);printf("/");
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
C++ - Ashqui Israel 132
void desc()
{
do
{
gotoxy(25,5);printf(" ");
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(25,11);printf(" ");
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
C++ - Ashqui Israel 133
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:
C++ - Ashqui Israel 134
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++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}
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
C++ - Ashqui Israel 135
}
}
void bdob()
{
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("º");
}
}
void ep()
{
int i;
clrscr();
gotoxy(1,1);printf("É");
gotoxy(80,1);printf("»");
for(i=2;i<=79;i++)
{
gotoxy(i,3);printf("ù");
gotoxy(i,21);printf("ù");
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("º");
}
}
void lucho()
{
int i;
clrscr();
gotoxy(1,1);printf("þ");
gotoxy(80,1);printf("þ");
for(i=2;i<=79;i++)
{
Función borde
Función borde
C++ - Ashqui Israel 136
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("þ");
}
}
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(25,11);printf(" ");
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
C++ - Ashqui Israel 137
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:
C++ - Ashqui Israel 138
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++)
{
gotoxy(i,1); printf("*");
gotoxy(i,24); printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i); printf("*");
gotoxy(80,i); printf("*");
}
}
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
C++ - Ashqui Israel 139
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
C++ - Ashqui Israel 140
}
while(op);
getch();
}
CORRIDO
Visualiza la opción y da por terminado el
programa
C++ - Ashqui Israel 141
Programa 38 ENUNCIADO
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++)
{
gotoxy(i,1); printf("*");
gotoxy(i,24); printf("*");
}
Ingreso las
librerías
Declaración de
variables
Función borde
Este proceso es
para realizar el
borde
C++ - Ashqui Israel 142
for(i=1;i<=24;i++)
{
gotoxy(1,i); printf("*");
gotoxy(80,i); printf("*");
}
}
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;
for(i=1;i<=limite1;i++)
{
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.
Utilizamos el for para poder
ingresar los valores del vector1 y
vector2, realizamos la operación en
donde se suman los dos vectores e
imprimimos el resultado, vamos
sumando fila para las correctas
posiciones cerramos el for y la
función suma.
C++ - Ashqui Israel 143
}
}
void resta(int limite1)
{
fila=8;
for(i=1;i<=limite1;i++)
{
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
Abrimos con una llave
Ingresamos el valor de la fila en la que va a
empezar a visualizarse los datos del vector.
Utilizamos el for para poder
ingresar los valores del
vector1 y vector2, luego se
utiliza un if para indicar que
el vector1 debe ser mayor
que el vector2 si la condición
se cumple realizamos la
operación en donde se resta
los valores del vector que
sea mayor e imprimimos el
resultado, cerramos el if y si
no se cumple la condición
escribimos un mensaje y no
se realiza la operación,
cerramos la llaves y vamos
sumando fila para las
correctas posiciones
Función para realizar la multiplicación
Abrimos con una llave
Ingresamos el valor de la fila en la que va a
empezar a visualizarse los datos del vector.
C++ - Ashqui Israel 144
for(i=1;i<=limite1;i++)
{
multivec[i]=vector1[i]*vector2[i];
gotoxy(40,fila); printf("%d",multivec[i]);
fila=fila+1;
}
}
void division(limite1)
{
fila=8;
for(i=1;i<=limite1;i++)
{
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;
}
}
Utilizamos el for para poder
ingresar los valores del vector1 y
vector2, realizamos la operación en
donde se mulitiplican los dos
vectores e imprimimos el resultado,
vamos sumando fila para las
correctas posiciones cerramos el
for y la función multi.
Función para realizar la división.
Abrimos con una llave
Ingresamos el valor de la fila en la que va a
empezar a visualizarse los datos del vector.
Utilizamos el for para poder
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
C++ - Ashqui Israel 145
void main()
{
do
{
clrscr();
borde();
gotoxy(15,3); printf("**OPERACIONES CON VECTORES Y FUNCIONES**");
gotoxy(10,5); printf("1.-SUMA");
gotoxy(10,7); printf("2.-RESTA");
gotoxy(10,9); printf("3.-MULTIPLICACION");
gotoxy(10,11); printf("4.-DIVISION");
gotoxy(10,13); printf("QUE OPCION DESEA==>");
scanf("%d",&op);
switch(op)
{
case 1:
do
{
clrscr();
borde();
gotoxy(30,3);printf("1.-SUMA");
gotoxy(11,7); printf("VECTOR 1");
gotoxy(21,7); printf("VECTOR 2");
gotoxy(40,7); printf("SUMA VECTOR");
gotoxy(10,5); printf("INGRESE LIMITE==>");
scanf("%d",&limite1);
Función principal del programa.
Abrimos con una llave
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.
C++ - Ashqui Israel 146
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(30,3); printf("2.-RESTA");
gotoxy(11,7); printf("VECTOR 1");
gotoxy(21,7); printf("VECTOR 2");
gotoxy(40,7); printf("RESTA VECTOR");
gotoxy(10,5); printf("INGRESE LIMITE==>");
scanf("%d",&limite1);
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
C++ - Ashqui Israel 147
while(opc==1);
break;
case 3:
do
{
clrscr();
borde();
gotoxy(30,3); printf("3.-MULTIPLICACION");
gotoxy(11,7); printf("VECTOR 1");
gotoxy(21,7); printf("VECTOR 2");
gotoxy(40,7); printf("MULTIPLICACION VECTOR");
gotoxy(10,5); printf("INGRESE LIMITE==>");
scanf("%d",&limite1);
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();
gotoxy(30,3); printf("4.-DIVISION");
Diseño de la tercera
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
Diseño de la cuarta
opción del menú de
opciones llamamos a las
funcione y utilizamos el
ciclo do while pa repetir el
C++ - Ashqui Israel 148
gotoxy(11,7); printf("VECTOR 1");
gotoxy(21,7); printf("VECTOR 2");
gotoxy(40,7); printf("DIVISION VECTOR");
gotoxy(10,5); printf("INGRESE LIMITE==>");
scanf("%d",&limite1);
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.
C++ - Ashqui Israel 149
C++ - Ashqui Israel 150
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++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++) proceso para realizer el borde
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}
C++ - Ashqui Israel 151
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 lazo for
} cierre de la funcion
main() Inicio de programa principal
C++ - Ashqui Israel 152
{
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
C++ - Ashqui Israel 153
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++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++) proceso para realizer el borde
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}
C++ - Ashqui Israel 154
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 de lazo for
} 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 lazo for
} Cierre de la funcion
main()
{
Do inicio de lazo do para la validacion de datos
{
fila=10;
C++ - Ashqui Israel 155
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
C++ - Ashqui Israel 156
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("*");
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("*");
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
C++ - Ashqui Israel 157
}
}
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
C++ - Ashqui Israel 158
}
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
C++ - Ashqui Israel 159
}
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
C++ - Ashqui Israel 160
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++)
{
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 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
C++ - Ashqui Israel 161
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
C++ - Ashqui Israel 162
{
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
C++ - Ashqui Israel 163
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.
C++ - Ashqui Israel 164
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.
C++ - Ashqui Israel 165
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);printf(" ");
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
C++ - Ashqui Israel 166
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
C++ - Ashqui Israel 167
#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);
Declaración de variables
Función global para el
borde, e inicio del ciclo, da
color
Inicio de la función
factor y del ciclo for
Condición para calcular los
factores impares y pares
Inicio del programa
principal
Inicio de el ciclo do while
llamamos al borde ye
ingresamos el limite
Ingreso de los
números pares
C++ - Ashqui Israel 168
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
C++ - Ashqui Israel 169
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
C++ - Ashqui Israel 170
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(); }
Programa 46 ENUNCIADO
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
C++ - Ashqui Israel 171
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++)
{
gotoxy(i,1);printf("*");
gotoxy(i,24);printf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);printf("*");
gotoxy(80,i);printf("*");
}
}
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
C++ - Ashqui Israel 172
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
C++ - Ashqui Israel 173
for(i=1;i<=limite;i++)
{
for(j=1;j<=limite;j++)
{
if(vecto[i]<vecto[j])
{
aux=vecto[i];
vecto[i]=vecto[j];
vecto[j]=aux;
}
}
}
fila=9;
for(i=1;i<=limite;i++)
{
gotoxy(20,fila);printf("%d",vecto[i]);
fila=fila+1;
}
fila=9;
for(i=1;i<=limite;i++)
{
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
C++ - Ashqui Israel 174
}
}
}
fila=9;
for(i=1;i<=limite;i++)
{
gotoxy(35,fila);printf("%d",vecto[i]);
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]
C++ - Ashqui Israel 175
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
C++ - Ashqui Israel 176
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();
gotoxy(1,1);printf("É");
gotoxy(80,1);printf("»");
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
C++ - Ashqui Israel 177
{
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("º");
}}
void primo(int l)
{
f=9;
f1=9;
for(j=1;j<=l;j++)
{
do
{
gotoxy(18,f);printf(" ");
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
C++ - Ashqui Israel 178
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
C++ - Ashqui Israel 179
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
C++ - Ashqui Israel 180
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);
gotoxy(i,1);cprintf("*");
gotoxy(i,24);cprintf("*");
}
for (i=1;i<=24;i++)
{
textcolor(i+1);
gotoxy(1,i);cprintf("*");
gotoxy(80,i);cprintf("*");
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
C++ - Ashqui Israel 181
}
}
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
C++ - Ashqui Israel 182
}
while(op==1);
getch();
}
CORRIDO DEL PROGRAMA
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
C++ - Ashqui Israel 183
#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
C++ - Ashqui Israel 184
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
C++ - Ashqui Israel 185
C++ - Ashqui Israel 186
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
C++ - Ashqui Israel 187
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(); }
CORRIDO DEL PROGRAMA
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
C++ - Ashqui Israel 188
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.
C++ - Ashqui Israel 189
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.
C++ - Ashqui Israel 190
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
C++ - Ashqui Israel 191
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:
C++ - Ashqui Israel 192
#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
Declaración de variables
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”
C++ - Ashqui Israel 193
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
C++ - Ashqui Israel 194
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
C++ - Ashqui Israel 195
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++)
{
gotoxy(i,1);cprintf("*");
gotoxy(i,24);cprintf("*");
}
for(i=1;i<=24;i++)
{
gotoxy(1,i);cprintf("*"); //IMPRECION DE *\\
gotoxy(80,i);cprintf("*");
} //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
C++ - Ashqui Israel 196
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\\
C++ - Ashqui Israel 197
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
C++ - Ashqui Israel 198
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
o Servicio médico que representa el 8% del valor de la matrícula
o Servicio de internet que el 9% del valor de la matrícula
o Servicio de canchas deportivas y servicios adicionales 11% del valor de la
matrícula
Si es fiscal paga 120,00
o Servicio médico que representa el 6% del valor de la matrícula
o Servicio de internet que el 8% del valor de la matrícula
o Servicio de canchas deportivas y servicios adicionales 10% del valor de la
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
C++ - Ashqui Israel 199
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
C++ - Ashqui Israel 200
} } 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
C++ - Ashqui Israel 201
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
C++ - Ashqui Israel 202
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
C++ - Ashqui Israel 203
#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 {
Declaración de variables
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
C++ - Ashqui Israel 204
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
C++ - Ashqui Israel 205
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;
C++ - Ashqui Israel 206
} 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
C++ - Ashqui Israel 207
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
C++ - Ashqui Israel 208
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
C++ - Ashqui Israel 209
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++ - Ashqui Israel 210
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
C++ - Ashqui Israel 211
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
C++ - Ashqui Israel 212
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();
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++)
{
Declaración de variables
Librerías
Función global para el
borde
C++ - Ashqui Israel 213
gotoxy(1,i);printf("º");
gotoxy(80,i);printf("º");
}
}
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
Inicio de la función
calcular la diagonal
principal
C++ - Ashqui Israel 214
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;
gotoxy(col,fil);printf("%d",mat[i][j]);
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;
gotoxy(col,fil);printf("%d",mat[i][j]);
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
C++ - Ashqui Israel 215
}
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++)
{
gotoxy(56,fil);printf("%d",vect[i]);
fil=fil+2;
Función para ordenar las
diagonales.
Calculamos el vector
descendente
C++ - Ashqui Israel 216
}
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++)
{
gotoxy(71,fil);printf("%d",vect[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
C++ - Ashqui Israel 217
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.
C++ - Ashqui Israel 218
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
C++ - Ashqui Israel 219
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
C++ - Ashqui Israel 220
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