Diseñe un Programa que imprima los primeros 10 números.

#include <stdio.h>
#include <conio.h>
main()
{
int i=1; /*Declaramos nuestro contador con su Valor Inicial*/
while(i<=10) /*Mientras i sea menor o igual a 10:*/
{
printf("%dt", i);/*Imprimir el valor de i*/
i+=1;/*Aumentar el contador en 1*/
}
getch();
return 0;
}
Ejemplo 4.2
Se desea conocer el promedio de los números mayores que cero, en una serie de números ingresados por el
usuario. De los cuales no se sabe la cantidad, haciendo uso de una bandera, diseñe un programa en el cual el
usuario ingrese los números que desee.
#include <stdio.h>
#include <conio.h>
main()
{
int i=0, sum=0, ban=1, n;
float prom;
while(ban==1)
{
printf("Ingrese un n£mero por Favor:n" ;
scanf("%d", &n);
if(n>0)
{
i=i+1;
sum+=n;
}

printf("Desea Ingresar Otro N£mero? (Si=1 y No=0)n" ;

scanf("%d", &ban);
}
prom=sum/i;

printf("************************************************************n" ;
printf("*** El Promedio de los numeros mayores que cero es: %.2f ***n", prom);

printf("************************************************************n" ;
getch();
return 0;
}
Ejercicio 4.3
En un salón se tienen las notas de 14, alumnos; de los cuales se desea saber cual fue el promedio de todas las notas,
cual fue la nota mayor y la nota menor. Así como la cantidad de aprobados en el curso (Para Aprobar la asignatura
se requiere de una nota mayor o igual a 6.0)
#include <stdio.h>
#include <conio.h>
main()
{
float suma=0, prom, menor=11, mayor=-1, nota;
int i=1,j=0;
while(i<=14)
{
printf("Ingrese la Nota del alumno %d:n", i);
scanf("%f", &nota);
while(nota<0.00 || nota >10.00)
{
printf("ERROR, la nota debe estar entre 0 y 10n" ;
scanf("%f", &nota);
}
if(nota>=6.00)
j=j+1;
if(nota>mayor)
mayor=nota;
if(nota<menor)
menor=nota;
i=i+1;
suma=suma+nota;
}
prom=suma/14;
printf("El Promedio es %.2fnn", prom);
printf("El total de Aprobados es %dn", j);
printf("La Mayor nota fue %.2fn", mayor);
printf("%.2f corresponde a la nota menorn", menor);
getch();
return 0;
}
Ciclo Controlado por contador.
En algunas ocasiones, sabemos a ciencia cierta el número de veces que se tiene que repetir una misma acción o
bloque de acciones. Y para ello es que nos sirve, esta estructura. Su sintaxis es la siguiente:
for( valor inicial; condición; incremento)
accion;
Donde:
Valor inicial: es el valor con el cual inicializamos nuestra variable de control.
Condición: si la cumple, ejecuta la acción o acciones e incrementa o decrementa la variable de control, sino la
cumple la condición, se sale del ciclo.
Incremento; que puede ser positivo o negativo (decremento).
Veamos un ejemplo sencillo:
Ejemplo 4.4:
Diseñe un programa que imprima los primeros 10 números:
#include <stdio.h>
#include <conio.h>
main()
{
int i;
for(i=1; i<=10; i++)
printf("%dt", i);
getch();
return 0;
}
ejemplo4.5
Diseñe un programa en C, que calcule las compras totales, realizadas por un grupo de 20 amas de casa. Luego con
esa información obtenga la media.
#include <stdio.h>
#include <conio.h>
main()
{
int i;
float compra, desvia, prom, varinza, sum=0;
for(i=1; i<=10; i++)
{
printf("Ingrese la cantidad que gast¢ la ama de casa %d:n", i);
scanf("%f", &compra);
while(compra<0)
{
printf("ERROR, la compra debe ser mayor que cero, vuelva a intentarlo:n" ;
scanf("%f", &compra);
}
sum=sum+compra;
}
prom=sum/12;
printf("El promedio de las compras es %.2fnna", prom);
getch();
return 0;
}

Cabe, mencionar que, en el ciclo for, podemos hacer cuentas decrecientes, es decir asignarle un valor grande a
nuestra variable de control y luego irla disminuyendo hasta un valor determinado.
Ejemplo 4.6
En un cine, se tienen 3 diferentes clases de boletos. Se pide que diseñe un programa en el cual:
a. se lea el precio de las 3 clase de boletos
b. Se lea el numero de boletos vendidos de cada tipo
c. Calcular cual boleto es el que se vendió menos
d. El total recaudado en taquilla
Además se sabe que durante el día se realizaron un total de n ventas.
#include <stdio.h>
#include <conio.h>
main()
{
float preciob1, preciob2, preciob3, sum=0, sum1=0, sum2=0, sum3=0;
int n, i, boletos1, boletos2, boletos3, boleto;
clrscr();
printf("ttBIENVENIDO(A)nnn" ;
printf("Ingrese el precio de los boletos 1:n" ;
scanf("%f", &preciob1);
while(preciob1<0)
{
printf("ERRORn" ;
scanf("%f", &preciob1);
}
printf("Ingrese el precio de los boletos 2:n" ;
scanf("%f",&preciob2);
while(preciob2<0)
{
printf("ERRORn" ;
scanf("%f", &preciob2);
}
printf("Ingrese el precio de los boletos 3:n" ;
scanf("%f",&preciob3);
while(preciob3<0)
{
printf("ERRORn" ;
scanf("%f", &preciob3);
}
printf("¨Cu ntas ventas se realizaron este d¡a?:n" ;
scanf("%d", &n);
while(n<0)
{
printf("ERRORn" ;
scanf("%d", &n);
}
for(i=1; i<=n; i++)
{

printf("Ingrese el Boleto:n" ;
scanf("%d", &boleto);
switch(boleto)
{

case 1: printf("Ingrese la cantidad de boletos vendidos:n" ;

scanf("%d", &boletos1);
sum1+=boletos1;
sum=sum+(boletos1*preciob1);
break;

case 2: printf("Ingrese la cantidad de boletos vendidos:n" ;

scanf("%d", &boletos2);
sum2+=boletos2;
sum=sum+(boletos2*preciob2);
break;

case 3: printf("Ingrese la cantidad de boletos vendidos:n" ;

scanf("%d", &boletos3);
sum3+=boletos3;
sum=sum+(boletos3*preciob3);
break;
default: printf("ERROR, Vuelva a intentarlonn" ;
break;
}
}
clrscr();
if(sum3<sum2 && sum3<sum1)

printf("Los Boletos que se vendieron menos fueron los boletos numero UNOnn" ;
if(sum2<sum3 && sum2<sum1)
printf("Los Boletos que se vendieron menos fueron los boletos numero DOSnn" ;
if(sum1<sum2 && sum1<sum3)
printf("Los Boletos que se vendieron menos fueron los boletos numero TRESnn" ;
printf("El total recaudado en taquilla, durante este dia fue: %.2fnn", sum);
getch();
return 0;
}
Ciclo Do... while
Es te ciclo funciona de la siguiente manera, realiza la acción o conjunto de acciones, luego evalúa una condición de
resultar cierta vuelve a realizar la/s accion/es. Cuando sea falsa, se sale del ciclo. Esta estructura, no está
lógicamente, estructurada, por ello, no hablaremos mucho, sin embargo realizaremos un par de ejemplos, de este
ciclo.
Formato :
do {
sentencia;
.
.
} while(<expL> ;
La diferencia fundamental, entre el ciclo while y do...while, es que en este ultimo, las sentencias se realizarán por lo
menos una vez, en cambio, con while, solo se cumplirán mientras se cumpla la condición, lo cual puede ser nunca.
Ejemplo 4.7
Programa que determina si un año es bisiesto o no. Y un año es bisiesto si es múltiplo de cuatro, pero excluyendo
aquellos que son múltiplos de 100 pero no de 400
#include <stdio.h>
#include <conio.h>
void main()
{
int anio;
char respuesta;
printf("nnnINICIO DEL PROGRAMAnnn" ;
printf("nnEl programa te pide un anio y te dice exactamente si es bisiesto o no" ;
do
{
/*ENTRADA DE DATOS*/
printf("nnIntroduzca un anio determinado " ;
scanf("%d",&anio);
/*PROCESO Y SALIDA DE DATOS*/
if ((anio%4==0 && anio%100!=0)||(anio%400==0)) printf("nnEl anio es bisiesto" ;
else printf("nnEl anio no es bisiesto" ;
printf("nnDesea introducir mas datosnn" ;
respuesta=getch();
} while(respuesta=='S' || respuesta=='s');
printf("nnnFIN DEL PROGRAMAnnn" ;
}
NOTA: este código ha sido tomado de "Practicas de Programación en C", de Fernando Muñoz Ledesma. Practica 3,
ejercicio 5.
Cuestionario
1. ¿qué es y cómo funciona un
ciclo?__________________________________________________________________________________________
__________________________
2. Cuál es la diferencia entre un contador y un
acumulador:____________________________________________________________________________________
_________________________
3. ¿cuál es la mejor manera de validar
datos?:________________________________________________________________________________________
_________________________
4. ¿cómo se evita un ciclo
infinito?:_______________________________________________________________________________________
___________________________
5. ¿Qué diferencia existe entre un ciclo de entrada asegurada y el do...
while?:______________________________________________________
Descubre donde está el error.
El siguiente código muestra la serie:
1^2+2^2+3^2....n^2
en el cual hay errores de lógica, de sintaxis o hasta de ejecución, puedes descubrirlos y corregirlos?
#include <stdio.h>
#include <conio.h>
main()
{
int n i, x, sum=0;
printf("Inrtroduzca el valor de n:n" ;
scanf("%d", &n);
while(n<0)
{
printf("Error, vuelva a digitar el valor de n:n" ;
scanf("%d", n);
}
for(i=1; i<=n, i++)
x=i*i;
sum+=n;
printf("El valor de la suma es:%dnn", sum)
getch();
return 0;
}

Ejemplo 5.1
Diseñe un programa que dados dos números enteros determine la suma y cual de ellos es mayor, usando dos
funciones diferentes.
#include <stdio.h>
#include <conio.h>
void suma (int a, int b); /*Declaraci¢n de la funci¢n*/
void mayor (int a, int b); /*Tipo de dato, nombre de la funci¢n y el tipo y nombre de los argumentos*/
main()
{
int a, b;
printf("Ingrese el valor de a:n" ;
scanf("%d", &a);
printf("Ingrese el valor de b:n" ;
scanf("%d", &b);
suma(a,b); /*Llamado de la funci¢n*/
mayor(a,b); /*Unicamente el nombre de la funci¢n y de los par metros*/
getch();
return 0;
}
void suma(int a, int b) /*Definici¢n de la funci¢n*/
{ /*Abrimos llaves al inicio de la definici¢n*/
int sum; /*Declaraci¢n de las variables locales*/
sum=a+b;
printf("El valor de la suma es %d:nn", sum);
} /*Fin de la funci¢n suma*/
void mayor(int a, int b)
{
if(a==b)
printf("Son igualesnn" ;
else
{
if(a>b)
printf("El valor de a es mayor que el de bnn" ;
else
printf("El valor de b es mayor que el de ann" ;
}
}
Definición de la Función
La función ha sido declarada, ha sido llamada y por lo tanto deber haber sido definida. Lo cual consta de dos partes,
las cuales son:
11. La Primera Línea
Que como su nombre lo indica, es la primera línea de la definición de la función y con ella le indicamos al
compilador que está en presencia de una función. Su formato es el siguiente:
Tipo_de_dato nombre_de_la_función (tipo y nombre de los argumentos)
12. Cuerpo de la función
Se inicia con una llave "{", y en ella, se pueden realizar asignaciones, cálculos, impresiones, así como la declaración
de las variables locales. Puede estar constituidas por estructuras secuenciales, selectivas, iterativas, anidamientos,
se pueden llamar otras funciones, etc; finaliza con "}". Puede devolver uno o ningún valor.
Ejemplo 5.2
Diseñe un Programa en C, que Dado un número entero y mayor que cero, Determine si es o no un número Primo.
Ojo, los números primos sólo son divisibles por el mismo y por la unidad (1).
#include <stdio.h>
#include <conio.h>
void primo (int numero);
main()
{
int numero, ban=1;
clrscr();
while(ban==1)
{
printf("Introduzca el n£mero por favor:n" ;
scanf("%d", &numero);
while(numero<0)
{
printf("ERROR, el valor del n£mero debe ser mayor que ceron" ;
scanf("%d", &numero);
}
primo(numero);
printf("¨Otro n£mero (si=1 y No=0)?n" ;
scanf("%d", &ban);
}
getch();
return 0;
}
void primo (int numero)
{
int div, primo=1;
for(div=2; div<numero; div++)
{
if(numero%div==0)
{
primo=0;
printf("%d NO es primonnn", numero);
return 0;
}
else
primo=1;
}
if(primo!=0)
printf("%d es primonnn", numero);
}
13. Funciones que devuelven un valor entero
Las funciones que devuelven algún valor, se les llama PROTOTIPOS DE FUNCIONES:
Antes de usar una función C debe tener conocimiento acerca del tipo de dato que regresara y el tipo de los
parámetros que la función espera.
El estándar ANSI de C introdujo una nueva (mejor) forma de hacer lo anterior respecto a las versiones previas
de C.
La importancia de usar prototipos de funciones es la siguiente:
Se hace el código mas estructurado y por lo tanto, más fácil de leer.
Se permite al compilador de C revisar la sintaxis de las funciones llamadas.
Lo anterior es hecho, dependiendo del alcance de la función. Básicamente si una función ha sido definida antes
de que sea usada (o llamada), entonces se puede usar la función sin problemas.
Si no es así, entonces la función se debe declarar. La declaración simplemente maneja el tipo de dato que la
función regresa y el tipo de parámetros usados por la función.
Es una práctica usual y conveniente escribir el prototipo de todas las funciones al principio del programa, sin
embargo esto no es estrictamente necesario.
Para declarar un prototipo de una función se indicara el tipo de dato que regresará la función, el nombre de la
función y entre paréntesis la lista del tipo de los parámetros de acuerdo al orden que aparecen en la definición de la
función. Por ejemplo:
int longcad(int n); Lo anterior declara una función llamada longcad que regresa un valor entero y acepta otro valor
entero como parámetro.
(Tomado de "Manual de C" de Héctor Tejada Villela)
Ejemplo 5.3
Diseñe un programa, que dado un número entero y mayor que cero, muestre su factorial. (El factorial de 5 es 120;
5x4x3x2x1=120)
#include <stdio.h>
#include <conio.h>
int factorial (int num);
main()
{
int num, ban=1;
clrscr();
while(ban==1)
{
printf("Ingrese el valor del n£mero por favor:n" ;
scanf("%d", &num);
while(num<0)
{
printf("ERROR, el valor del n£mero debe ser mayor que cero:n" ;
scanf("%d", &num);
}
printf("El valor del factorial es %dnn", factorial (num));
printf("¨Desea Realizar otro calculo?Si=1 y No=0n" ;
scanf("%d", &ban);
}
getch();
return 0;
}
int factorial (int num)
{
int sum=1, i;
for(i=2; i<=num; i++)
{
sum=sum*i;
}
return (sum);
}
Explicación:
Quizá, lo único nuevo, e importante de explicar, radica en la llamada y la definición de la función. Cuando una
función nos devolverá un valor entero, al identificador de dicha función debe precederle el tipo de dato. En el lugar,
donde llamamos la función, es que aparecerá el valor que nos devuelva, como valor de retorno. En nuestro ejemplo,
en una impresión. Y al momento de definirla, no se nos debe olvidar, colocarle la sentencia return(); ya que,
mediante esta declaratoria, está retornando el valor calculado.
Pero, que sucede cuando se está trabajando, con valores bastante grandes, al utilizar solamente el int, se producirá
un error lógico; ya que como valor de retorno podría ser un cero o una cifra negativa. Por tanto debemos usar el
tipo de dato "long int".
Ejemplo 5.4
Diseñe un programa, que dada una cifra entera y mayor que cero, sea elevada a una potencia introducida por el
usuario, la cual. (Ejemplo: 5^2=25).
#include <stdio.h>
#include <conio.h>
long int potencia (int base, int exponente);
main()
{
int base, exponente;
clrscr();
printf("La Base es:n" ;
scanf("%d", &base);
while (base<0)
{
printf("ERROR, el dato debe ser mayor que cero:n" ;
scanf("%d", &base);
}
printf("El Exponente es:n" ;
scanf("%d", &exponente);
printf("%d ^ %d es %ldnn", base, exponente, potencia(base,exponente));
getch();
return 0;
}
long int potencia (int base, int exponente)
{
long int sum=0, i,x;
for(i=1; i<exponente; i++)
{
x=base*base;
sum=sum+x;
}
return (sum);
}

1. Un banco ha solicitado se diseñe un programa que permita encriptar la información de Las

contraseñas (4 números) digitada por teclado (como un único numero) hasta el servidor principal,
utilizando el siguiente criterio, el primer número se envía de último, el segundo, de penúltimo, el
tercer numero pasa a la segunda posición, el último pasa a ser el primero: ejemplo
Ejemplo: Sea 7458, se debe enviar como 8547

#include <stdio.h>
#include <stdlib.h>
int a,b,c,d;
int main
{
printf("\ningrese el primer numero de su contraseña");
scanf("%d",&a);
printf("\ningrese el segundo numero de su contraseña");
scanf("%d",&b);
printf("\ningrese el tercero numero de su contraseña");
scanf("%d",&c);
printf("\ningrese el cuarto numero de su contraseña");
scanf("%d",&d);
printf("\nencriptando contraseña");
printf("\nsu contraseña es:\t",d,c,b,a);
syatem("pause");
return 0;
}

2. Escribir un programa para calcular la fecha del siguiente día a partir de una fecha digitada desde
el teclado por el usuario ( dd, mm, aaaa ) e imprimirla. (tenga en cuenta los años bisiestos.)

#include<iostream>
using namespace std;

int main()
{
int d, m, a, dm, t, i;

cout << "Ingrese fecha (dd mm aa): "; // años de dos digitos
cin >> d >> m >> a;

t = 365 * a + ( a - 1 ) / 4; /* dias hasta el anno anterior

desde 1900 (ej. 1903,incluye
el anno 1900, 1901, 1902: 3
annos ).
y un dia por cada anno bisiesto,
hasta el anno anterior (ej.
1915, hasta el 14 tenemos: 1904,
1908, 1912 o sea 14/4 = 3. */

for( i = 1; i<m; t += dm, i++ ) //dias hasta el mes anterior

switch(i)
{
case 1 :
case 3 :
case 5 :
case 7 :
case 8 :
case 10:
case 12: dm = 31;
break;
case 4 :
case 6 :
case 9 :
case 11: dm = 30;
break;
case 2 : if( a > 0 && a % 4 == 0 )
dm = 29;
else
dm = 28;
}

t+=d; //dias hasta la fecha

t%=7; /*dias que sobran despues de reducir las semanas

si 1 de enero fue lunes, el 7 del mismo mes
(t%7 == 0) sera domingo */

switch ( t )
{
case 0: cout << "Domingo\n";
break;
case 1: cout << "Lunes\n";
break;
case 2: cout << "Martes\n";
break;
case 3: cout << "Miercoles\n";
break;
case 4: cout << "Jueves\n";
break;
case 5: cout << "Viernes\n";
break;
case 6: cout << "Sabado\n";
break;
}
cin.ignore();
cin.get();
return 0;
}

3. Se lee un número de máximo tres dígitos (verifique que efectivamente sea de máximo tres dígitos)
y se debe determinar si es un número capicúa, es decir, que leído de izquierda a derecha es igual
que leído de derecha a izquierda. Por ejemplo: 727, 343, etc.

#include "iostream.h"
#include "conio.h"
#include "math.h"
// Retorna la cantidad de digitos que tiene un numero
int numeroDigitos(int numero)
{
int i=1;

while(numero/10!=0)
{
numero=numero/10;
i++;
}

return i;
}

/* Si "pos" es una poscion invalida, retorna -1, sino

Retorna el digito de la posicion "pos" de un numero */

int obtenerDigito(int numero, int pos)

{
int numDigitos, i, digito;

// Obtenemos el numero de digitos de un numero

numDigitos=numeroDigitos(numero);

// Verificamos si "pos" es una posicion invalida

if(pos<=0 || pos>numDigitos)
digito=-1;
else
{
i=1;

// i llegara hasta el numero de divisiones efectivas para obtener el digito

while(i<=numDigitos-pos)
{
numero=numero/10;
i++;
}

digito=numero%10;
}

return digito;
}

// Determina si un numero es capicua

bool esCapicua(int numero)
{
bool esCapicua=true;
int numDigitos, medio, i, numero1, numero2;

// Obtenemos el numero de digitos de un numero

numDigitos=numeroDigitos(numero);
medio=numDigitos/2;
i=1;

/* el indice i se detendra hasta llegue a "medio" o hasta que

ya se halla determinado que esCapicua es false */
while(i<=medio&&esCapicua)
{
/* numero1 y numero2 seran detrminados tomando los extremos del subnumero
segun el indice i */
numero1=obtenerDigito(numero,i);
numero2=obtenerDigito(numero,numDigitos-i+1);

// Comparamos si los dos numeros son diferentes

if(numero1!=numero2)
esCapicua=false;

i++;
}

return esCapicua;
}

int main()
{
int numero;

cout<<"Ingrese numero: "<<endl;

cin>>numero;

if(esCapicua(numero))
cout<<"SI es Capicua";
else
cout<<"NO es Capicua";

cout<<endl;
system("PAUSE");

return 0;

4. En una organización se tiene a los empleados agrupados por categoría, los de categoría 1 ganan
$20.000, los de categoría 2, $15.000, los de categoría 3, $10.000 y los de categoría 4, $7.500. Se
quiere un algoritmo que permita determinar cuanto debe pagarse a un empleado si se conoce el
número de horas que trabajó durante el mes y la categoría a la que pertenece. Se sabe que a todos
se les descuenta un 7.2% por concepto de salud, y si el salario total devengado (mensual) es menos
de 1 ´000.000, se le da un subsidio del 15% sobre su salario mensual (sin descuentos).

#include<stdio.h>
#include<stdlib.h>
#define DE 7.2
int hora,phora,sueldo,des,sub,ca;
int main()
{
printf("\ningrese numero de horas que trabaja");
scanf("%d",&hora);
printf("\ningreae la categoria a la que pertenece");
printf("\nmarque 1 categoria 1");
printf("\nmarque 2 categoria 2");
printf("\nmarque 3 categoria 3");
printf("\nmarque 4 categoria 4");
scanf("%d",&ca);
if(ca==1)
{
des=(sueldo*DE)/100;
sueldo=(hora*20000)-des;
if(sueldo<1000000)
{
sub=(15*sueldo)/100;
sueldo=sueldo+sub;
printf("su sueldo es:%d",sueldo);
}
}
if(ca==2)
{
des=(sueldo*DE)/100;
sueldo=(hora*15000)-des;
if(sueldo<1000000)
{
sub=(15*sueldo)/100;
sueldo=sueldo+sub;
printf("su sueldo es:%d",sueldo);
}

}
if (ca==3)
{
des=(sueldo*DE)/100;
sueldo=(hora*10000)-des;
if(sueldo<1000000)
{
sub=(15*sueldo)/100;
sueldo=sueldo+sub;
printf("su sueldo es:%d",sueldo);
}
}
if (ca==4)
{
des=(sueldo*DE)/100;
sueldo=(hora*7500)-des;
if(sueldo<1000000)
{
sub=(15*sueldo)/100;
sueldo=sueldo+sub;
printf("su sueldo es:",sueldo);
}
}
system("pause");
return 0;
}

5. Elabore un programa que tenga cuatro niveles de seguridad (documéntese sobre niveles de
seguridad) para un programa, si el usuario logra ingresar imprimir el mensaje "Bienvenido", en caso
contrario imprimir "Error clave" y el nivel del error

6. Escriba un programa para calcular si un número es primo o no, recuerde que los
números primos son aquellos que solo son divisibles por la unidad y por ellos mismos:
ejemplo 5, 11, 17
#include<stdio.h>
#include<stdlib.h>

int main()
{
long Num,divisor=2;
printf("\t Introducir el Numero = ");
scanf("%ld",&Num);
while(divisor<Num)
{ while( Num % divisor != 0)
divisor=divisor+1;
if(Num== divisor)
printf("t %ld es PRIMO n",Num);
else
printf("t%ld NO es PRIMO ,pues ES multiplo de %ld n",Num,divisor);
break;
}
system("pause");
return 0;
7. Lea los valores de los lados de un triángulo. Detecte y muestre un mensaje correspondiente a su
tipo (EQUILÁTERO, ISÓSCELES, O ESCALENO)

#include<iostream>
#include<cmath>
#include<stdlib.h>
using namespace std;
int a;
int b;
int c;
int main() {
cout<<"ingrese el lado a del triangulo"<<endl;
cin>>a;
cout<<"ingrese el lado b del triangulo"<<endl;
cin>>b;
cout<<"ingrese el ladoc del triangulo"<<endl;
cin>>c;
if (a==b && b==c) {
cout<<"triángulo equilátero"<<endl;
}
else
{
if (a==b || b==c || a==c) {
cout<<" triángulo isoceles"<<endl;
}
else {
cout<<"triángulo escaleno"<<endl;
}
}
system("pause");
return 0;
}

8. Desarrolle un programa que permita seleccionar personal para un empleo de un total de N

aspirantes. Los aspirantes deben cumplir las siguientes condiciones para ser aceptados:

Mayores de edad Ser

ingeniero titulado Tener
experiencia laboral
Al final el programa debe mostrar el total de aspirantes aceptados

#include<iostream>
#include<cmath>
#include<stdlib.h>
using namespace std;

int main()
{
float suma=0;
float ac;
float i=0;
int n;
float I;
int e;
int g;
int j;
int APIRANTES[200];
ac=0;
i=0;
cout<<"ingrse la cantidad de empleados que va a entrvistar"<<endl;
cin>>n;
for (i=1;i<=n;i++) {
cout<<"empeado"<<i<<endl;
cout<<" Es mayor de edad?"<<endl;
cout<<"si=1 no=2"<<endl;
cin>>e;
cout<<"ingeniero titulado?"<<endl;
cout<<"si=1 no=2"<<endl;
cin>>g;
cout<<"etiene experiencia laboral?"<<endl;
cout<<"si=1 no=2"<<endl;
cin>>j;
if (e==1 && g==1 && j==1) {
ac=suma+i;
}
}
cout<<"el numero de empleados aceptados es:"<<ac<<endl;
system("pause");
return 0;
}

9. Elaborar un programa que convierta un número entero positivo, menor a 257 a

sistema binario

#include <stdio.h>
#include <conio.h>
#include<stdlib.h>
main()
{
float a[16];
int ne,x,swi;
printf("Este progrograma esta diseñado para convertir un numero entero positivo decimal a
binario.");
printf("\n\nPara continuar con el programa presione ENTER");
getch();
intonum:
printf("Introduzca el numero entero positivo que desea convertir a binario:");
scanf("%i",&ne);
if(ne<0)
{
err:
printf("Ha introducido un numero negativo, si desea intentar nuevamente presione 1 o si desea salir
del programa presione 2\n");
scanf("%i",&swi);
if(swi==1)
{
printf("\n");
goto intonum;
}
else
if(swi==2)
{
printf("fin");
}
else
{
printf("Error de entrada");
goto err;
}
}
else
{
for(x=15;x>=0;x=x-1)
{
if(ne<257)
{
a[x]=ne%2;
}
else
{
a[x]=0;
}
ne=ne/2;
}
for(x=0;x<=15;x++)
{
printf("%.0f",a[x]);
}
}
system("pause");
return 0;
}

10. Dada tu fecha de nacimiento (mes, día, año) indicar cuantos días (exactos) han transcurrido
desde ese año.

#include<stdio.h>
#include<stdlib.h>
int dia;
int mes;
int ano;
int cad;
int cad1;
int main()
{
printf("\ningrese el numero del dia de nacimiento");
scanf("%d",&dia);
printf("\ningrese el numero del mes de nacimiento");
printf("\nenero=1");
printf("\nfebrero=2");
printf("\nmarzo=3");
printf("\nabril=4");
printf("\nmayo=5");
printf("\njunio=6");
printf("\njulio=7");
printf("\nagosto=8");
printf("\nseptiembre=9");
printf("\noctubre=10");
printf("\nnobiembre=11");
printf("\ndiciembre=12");
scanf("%d",&mes);
printf("\ningrese el numero del año completo de nacimiento");
scanf("%d",&ano);
if(mes==4||mes==6||mes==9||mes==11)
{
cad1=(30-dia)+(30*3)+(31*7)+(28);
cad=(2009-ano)*cad1;
printf("los dias vividos son:%d",cad);
}
else
{
if (mes==1||mes==3||mes==5||mes==7||mes==8||mes==10||mes==12)
cad1=(31-dia)+(30*4)+(31*6)+(28);
cad=(2009-ano)*cad1;
printf("los dias vividos son:%d",cad);
}
if(mes==2)
{
cad1=(28-dia)+(30*4)+(31*7);
cad=(2009-ano)*cad1;
printf("los dias vividos son:%d",cad);
}

system("pause");
return 0;
}

11. Elabore un programa que genere un número aleatorio y que les dé la posibilidad a dos jugadores
de adivinar dicho número, el algoritmo debe pedir el número de partidas, intercalar los turnos para
adivinar, mostrar el ganador por partida y el ganador final. El número debe estar entre 0-100. (Use la
función random.)

12. Elabore un programa que lea las ventas de (n) número de vendedores, para los productos (A, B,
C, D y C), si los precios de los productos son ($1000, $2345, $3876, $1235 y $550) respectivamente,
calcule el número individual y total de productos vendidos, las ventas totales por producto, el
promedio total de ventas, el producto mas vendido, el menos vendido, el vendedor que más ventas
realizó

#include<iostream>
#include<cmath>
#include<stdlib.h>
using namespace std;

int main() {

int nipa=0;

float nipb;
float nipc;
float nipd;
float nipe;
float ntp;
float vtpa;
float vtpb;
float vtpc;
float vtpd;
float vtpe;
float ptv;
float pmv;
float pmev;
float vmv;
float a;
float suma;
int n;
float A;
int b;
int c;
int d;
int e;
int f;
int VENTAS[200];
nipb=0;
nipc=0;
nipd=0;
nipe=0;
ntp=0;
vtpa=0;
vtpb=0;
vtpc=0;
vtpd=0;
vtpe=0;
ptv=0;
pmv=0;
pmev=0;
vmv=0;
a=0;
suma=0;
cout<<"ingrese la cantidad de vendedores que va a nalizar"<<endl;
cin>>n;
for (a=1;a<=n;a++) {
cout<<"vendedor"<<a<<endl;
cout<<"cantidad del producto a vendida?"<<endl;
cin>>b;
cout<<"cantidad del producto b vendida?"<<endl;
cin>>c;
cout<<"cantidad del producto c vendida?"<<endl;
cin>>d;
cout<<"cantidad del producto d vendida?"<<endl;
cin>>e;
cout<<"cantidad del producto e vendida?"<<endl;
cin>>f;
nipa=suma+b;
nipb=suma+c;
nipc=suma+d;
nipd=suma+e;
nipe=suma+f;
ntp=suma+b+c+d+e+f;
vtpa=100*b;
vtpb=2345*c;
vtpc=3876*d;
vtpd=1235*e;
vtpe=550*f;
ptv=(vtpa+vtpb+vtpc+vtpd+vtpe)/5;
if (nipa>nipb && nipa>nipc && nipa>nipd && nipa>nipe) {
cout<<"el producto mas vendido es el a"<<endl;
} else {
if (nipb>nipa && nipb>nipc && nipb>nipd && nipb>nipe) {
cout<<"el producto mas vendido es el b"<<endl;
} else {
if (nipc>nipa && nipc>nipb && nipc>nipd && nipc>nipe) {
cout<<"el producto mas vendido es el c"<<endl;
} else {
if (nipd>nipa && nipd>nipb && nipd>nipc && nipd>nipe) {
cout<<"el producto mas vendido es el d"<<endl;
} else {
if (nipe>nipa && nipe>nipb && nipe>nipc && nipe>nipd) {
cout<<"el producto mas vendido es el e"<<endl;
}
}
}
}
}
if (nipa<nipb && nipa<nipc && nipa<nipd && nipa<nipe) {
cout<<"el producto menos vendido es el a"<<endl;
} else {
if (nipb<nipa && nipb<nipc && nipb<nipd && nipb<nipe) {
cout<<"el producto mas vendido es el b"<<endl;
} else {
if (nipc<nipa && nipc<nipb && nipc<nipd && nipc<nipe) {
cout<<"el producto mas vendido es el c"<<endl;
} else {
if (nipd<nipa && nipd<nipb && nipd<nipc && nipd<nipe) {
cout<<"el producto mas vendido es el d"<<endl;
} else {
if (nipe<nipa && nipe<nipb && nipe<nipc && nipe<nipd) {
cout<<"el producto mas vendido es el e"<<endl;
}
}
}
}
}
}
cout<<"el numero de productos a vendidos es:"<<nipa<<endl;
cout<<"el numero de productos b vendidos es:"<<nipb<<endl;
cout<<"el numero de productos c vendidos es:"<<nipc<<endl;
cout<<"el numero de productos d vendidos es:"<<nipd<<endl;
cout<<"el numero de productos e vendidos es:"<<nipe<<endl;
cout<<"el numero total de productos e vendidos es:"<<ntp<<endl;
cout<<"las ventas totales por producto a es:"<<vtpa<<endl;
cout<<"las ventas totales por producto b es:"<<vtpb<<endl;
cout<<"las ventas totales por producto c es:"<<vtpc<<endl;
cout<<"las ventas totales por producto d es:"<<vtpd<<endl;
cout<<"las ventas totales por producto e es:"<<vtpe<<endl;
cout<<"el promedio total de ventas es:"<<ptv<<endl;
system("pause");
return 0;
}

13. Desarrolle un programa que mediante la construcción de un menú, permita la utilización de por
lo menos cinco (5), funciones de la librería math.h

#include<iostream>
#include<cmath>
#include<stdlib.h>
using namespace std;
#define SIN_TIPO float
float salir;
float n;
float x;
int opcion;
float r;
float f;
string primo;
float nu;
int main() {
salir=0;
cout<<"Ingresar Numero:"<<endl;
cin>>n;
do {
cout<<" "<<endl;
cout<<"Presione Enter para continuar"<<endl;
cin>>x;
cout<<"1 - Seno, Coseno, ArcoTangente"<<endl;
cout<<"2 - Lograritmo Natural, Funcion Exponencial"<<endl;
cout<<"3 - Truncar, Redondear"<<endl;
cout<<"4 - Raiz Cuadrada"<<endl;
cout<<"5 - Valor Absoluto"<<endl;
cout<<"6 - Separar parte entera y decimal"<<endl;
cout<<"7 - Hallar Factorial"<<endl;
cout<<"8 - Averiguar si es primo"<<endl;
cout<<"9 - Ingresar Otro Numero"<<endl;
cout<<" "<<endl;
cout<<"0 - para Salir"<<endl;
cout<<" "<<endl;
cin>>opcion;
switch (opcion) {
case 1:
cout<<"Seno:"<<sin(n)<<endl;
cout<<"Coseno:"<<cos(n)<<endl;
cout<<"ArcTangente:"<<atan(n)<<endl;
break;
case 2:
if (n<=0) {
cout<<"El numero debe ser mayor a cero!"<<endl;
}
else {
cout<<"Log Nat.:"<<log(n)<<endl;
cout<<"Func Expon.:"<<exp(n)<<endl;
}
break;
case 3:
cout<<"Turncar:"<<floor(n)<<endl;
cout<<"Redondear:"<<ceil(n+.5)<<endl;
break;
case 4:
cout<<"Raiz Cuad.:"<<sqrtf(n)<<endl;
break;
case 5:
cout<<"Valor Abs.:"<<abs(n)<<endl;
break;
case 6:
cout<<"Parte Entera:"<<floor(n)<<endl;
cout<<"Parte Decimal:"<<n-floor(n)<<endl;
break;
case 7:
if (n!=floor(n)) {
cout<<"El numero debe ser entero!"<<endl;
}
else {
if (abs(n)>50) {
cout<<"Resultado muy grande!"<<endl;
}
else {
r=1;
f=1;
while (f<=abs(n)) {
if (n<0)
{
r=(-f)*r;
}
else {
r=f*r;
}
f=f+1;
}
cout<<"Factorial:"<<r<<endl;
}
}
break;
case 8:
if (n!=floor(n)) {
cout<<"El numero debe ser entero!"<<endl;
}
else {
primo="Si";
if (n/2==floor(n/2)) {
primo="No";
}
if (n<0) {
nu=n*-1;
}
else {
nu=n;
}
nu=sqrtf(nu);
f=3;
while (f<=nu && primo=="Si") {
if (n/f==floor(n/f)) {
primo="No";
}
f=f+2;
}
cout<<"Numero Primo:"<<primo<<endl;
if (f==3) {
f=4;
}
if (primo=="No") {
cout<<n<<"="<<f-2<<"x"<<n/(f-2)<<endl;
}
}
break;
case 9:
cout<<"Ingrese Numero:"<<endl;
cin>>n;
break;
case 0:
salir=1;
break;
default:
cout<<"Opcion No Valida!"<<endl;
 break;
}
}
while (salir==1);
system("pause");
return 0;
}

14. Escriba un programa que visualice el siguiente dibujo

15. Escribir un programa, mediante funciones visualice un calendario de la siguiente forma:

Aquí esta la respuesta de aquel que pidió la clase de los números complejos hecho por mi en código puro (listo
para compilar gráfico o en consola)
ESTO ES UN UN PROYECTO.

#ifndef COMPLEJOS_H
#define COMPLEJOS_H
#include <iostream>

using namespace std;

class Complejo
{
private:

double real;
double imaginario;

public:
Complejo();
Complejo(double real, double im);
Complejo operator+(Complejo sumando);
Complejo operator-(Complejo restando);
Complejo operator*(Complejo producto);
Complejo operator/(Complejo divisor);

void setReal(double numeroReal);

void setImaginario(double numeroImaginario);
void getComplejo(double r, double i);
double getReal();
double getImaginario();
void Menu();
};
cout << c1.getReal() << " +i " << c1.getImaginario() << endl;
cout << c1 << endl;
/**
*Imprime el complejo en pantalla.
*Sobre carga del operador << para imprimir correctamente el complejo, ya sea
*de la forma re + im, o re - im
*/
std::ostream &operator<<(std::ostream &out, Complejo c);
#endif

/*Este es un archivo que lo tienes que guardar con la extencion ( .h ), lo siguiente va en otro archivo del
mismo proyecto.*/

#include "complejo.h"

Complejo::Complejo()
{
real = 0.0;
imaginario = 0.0;
}

Complejo::Complejo(double real, double im)

{
this -> real = real;
this ->imaginario = im;
}

void Complejo::getComplejo(double r, double i)

{
real=r;
imaginario=i;
}

void Complejo::setReal(double numeroReal)

{
real = numeroReal;
}

void Complejo::setImaginario(double numeroImaginario)

{
imaginario = numeroImaginario;
}

double Complejo::getReal()
{
return real;
}

double Complejo::getImaginario()
{
return imaginario;
}

Complejo Complejo::operator+(Complejo sumando)

{
Complejo resultado;

resultado.setReal(this->real + sumando.getReal());
resultado.setImaginario(this->imaginario + sumando.getImaginario());
return resultado;
}

Complejo Complejo::operator-(Complejo restando)

{
Complejo resultado;

resultado.setReal(this->real - restando.getReal());
resultado.setImaginario(this->imaginario - restando.getImaginario());
return resultado;
}

Complejo Complejo::operator/(Complejo producto)

{
Complejo resultado;

resultado.getComplejo(((this->real * producto.getReal())-(this->imaginario * producto.getImaginario())),((this-

>real * producto.getImaginario() ) +
(this->imaginario * producto.getReal() )));
return resultado;
}

Complejo Complejo::operator/(Complejo divisor)

{
Complejo resultado;

resultado.getComplejo((((this->real * divisor.getReal()) + (this->imaginario *

divisor.getImaginario()))/((divisor.getReal()
* divisor.getReal())+(divisor.getImaginario() * divisor.getImaginario()))),(((this->real * divisor.getImaginario() )
-
(this->imaginario * divisor.getReal() ))/((divisor.getReal() * divisor.getReal())+(divisor.getImaginario() *
divisor.getImaginario()))));
return resultado;
}

void Complejo::Menu()
{
cout<<"1)Suma"<<endl;
cout<<"2)Resta"<<endl;
cout<<"3)Multiplicacion"<<endl;
cout<<"4)Divicion"<<endl;
cout<<"5)Salir"<<endl;
cout<<"\t\nOpcion: "<<endl;
}

std::ostream &operator<<(std::ostream &out Complejo c)

{
if (0.0f > c.getImaginario())
{
out << c.getReal() << " -i " << -c.getImaginario();
}
else
{
out << c.getReal() << " + i " << c.getImaginario();
}
return out;
}

/*Aqui se termina este archivo y y se guarda con la extencion cpp y despues biene el Main del programa*/

#include "complejo.h"
Complejo calc,comp1,comp2,res;
int main(int argc, char *argv[])
{

double real;
double imag;
short opcion;

do
{
system("cls");
calc.Menu();
cin>>opcion;

switch (opcion)
{
case 1:
cout<<"Escribe el primer real: ";
cin>>real;
cout<<"Escribe el primer imaginario: ";
cin>>imag;

comp1= Complejo(real,imag);

cout<<"Escribe el segundo real: ";

cin>>real;
cout<<"Escribe el segundo imaginario: ";
cin>>imag;

comp2 = Complejo(real,imag);

res = comp1 + comp2;//res = comp1.suma(comp2);

if (res.getImaginario() <0.0)
{
cout<<"El resultado es: "<< res.getReal() <<"+ i"<< -res.getImaginario();//-1*res.getImaginario();
}
else
{
cout<<"El resultado es: "<< res.getReal() <<"+ i"<< res.getImaginario();
}
break;
case 2:
cout<<"Escribe el primer real: ";
cin>>real;
cout<<"Escribe el primer imaginario: ";
cin>>imag;

comp1=Complejo(real,imag);

cout<<"Escribe el segundo real: ";

cin>>real;
cout<<"Escribe el segundo imaginario: ";
cin>>imag;

comp2= Complejo(real,imag);

res = comp1 - comp2;//res = comp1.resta(comp2);

if (res.getImaginario() <0.0)
{
cout<<"El resultado es: "<< res.getReal() <<"+ i"<< -res.getImaginario();//-1*res.getImaginario();
}
else
{
cout<<"El resultado es: "<< res.getReal() <<"+ i"<< res.getImaginario();
}
break;
case 3:
cout<<"Escribe el primer real: ";
cin>>real;
cout<<"Escribe el primer imaginario: ";
cin>>imag;
comp1= Complejo(real,imag);

cout<<"Escribe el segundo real: ";

cin>>real;
cout<<"Escribe el segundo imaginario: ";
cin>>imag;

comp2= Complejo(real,imag);

res = comp1 * comp2;//res = comp1.multi(comp2);

if (res.getImaginario() <0.0)
{
cout<<"El resultado es: "<< res.getReal() <<"+ i"<< -res.getImaginario();//-1*res.getImaginario();
}
else
{
cout<<"El resultado es: "<< res.getReal() <<"+ i"<< res.getImaginario();
}
break;
case 4:
cout<<"Escribe el primer real: ";
cin>>real;
cout<<"Escribe el primer imaginario: ";
cin>>imag;

comp1= Complejo(real,imag);

cout<<"Escribe el segundo real: ";

cin>>real;
cout<<"Escribe el segundo imaginario: ";
cin>>imag;

comp2= Complejo(real,imag);

res = comp1 / comp2;//res = comp1.divi(comp2);

if (res.getImaginario() <0.0)
{
cout<<"El resultado es: "<< res.getReal() <<"+ i"<< -res.getImaginario();//-1*res.getImaginario();
}
else
{
cout<<"El resultado es: "<< res.getReal() <<"+ i"<< res.getImaginario();
}
break;
case 5:
cout<<"Adios";
break;
default:
cerr<<"Error";
break;
}

cin.get();
cin.get();
}while(opcion != 5);

return EXIT_SUCCESS;
}