Guías Prácticas de Algoritmos

Escuela Tcnica N1 Otto Krause 4to Computacin 2da
Algoritmos y estructura de
datos
Codificacin de guas prcticas
Fernndez Diego
14
ndice
Primera Gua Introduccin a variables y condiciones ____________________________ 3
2
Segunda Gua Condiciones compuestas / Switch _______________________________ 6

Tercera Gua Parte 1 Estructuras de control __________________________________ 16
Tercera Gua Parte 1 (Funciones) Estructuras de control ________________________ 43
Tercera Gua Parte Dos (Solo Funciones) Estructuras de Control __________________ 75
Cuarta Gua Vectores _____________________________________________________ 94
Quinta Gua Vectores 2 / Ordenamiento / Punteros / Funciones ________________ 110
Sexta Gua Matrices _____________________________________________________ 125
Sexta Gua Matrices (Funciones) __________________________________________ 135
Evaluacin Matrices Introduccin a Matrices ________________________________ 147
Trabajo Prctico en Clase Cadenas _________________________________________ 153
Parte Terica _______________________________________________________________ 153
Parte Prctica _______________________________________________________________ 154
Prctica con funciones en clases ____________________________________________ 160
Primera Gua Introduccin a variables y condiciones

//Ejercicio 1
#include <stdio.h>
#include <stdlib.h>
void main()
{
int a, b;
printf("Ingrese valor de a: ");
scanf("%d", &a);
printf("Ingrese valor de b: ");
scanf("%d", &b);
printf("El valor de a es: %d\nEl valor de b es: %d\n\n");
system("Pause");
}
//Ejercicio 2
#include <stdio.h>
#include <stdlib.h>
void main()
{
int fuerza, presion, super;
printf("Ingrese la superficie: ");
scanf("%d", &super);
printf("Ingrese la fuerza ejercida: ");
scanf("%d", &fuerza);
super = super * super;
presion = fuerza / super;
printf("La presion total es de %d \n", presion);
system("Pause");
}
//Ejercicio 3
#include <stdio.h>
#include <stdlib.h>
void main()
{
4
int r1, r2, r3, r4, r5, rt;

printf("Ingrese el valor de R1:
scanf("%d", &r1);
scanf("%d", &r2);
scanf("%d", &r3);
scanf("%d", &r4);
scanf("%d", &r5);
rt = r1 + r2 + r3 + r4 + r5;
printf("El valor de resistencia
system("Pause");
");
");
");
");
");
total (Rt) es: %d ohms. \n", rt);
}
-------------------------------------------------------------//Ejercicio 4
#include <stdio.h>
#include <stdlib.h>
void main()
{
int valor, octparte;
printf("Ingrese el valor a dividir: ");
scanf("%d", &valor);
octparte = valor / 8;
printf("La octava parte del numero ingresado es: %d \n", octparte);
system("Pause");
}
//Ejercicio 5
#include <stdio.h>
#include <stdlib.h>
void main()
{
int lado1, lado2, peri, area;
printf("Ingrese el valor del lado 1 en cm: ");
scanf("%d", &lado1);
peri = (lado1 * 2) + (lado2 * 2);
area = lado1 * lado2;
printf("El perimetro del rectangulo es de: %d cm. \n", peri);
printf("El area del rectangulo es de: %d cm. \n", area);
system("Pause");
}
-------------------------------------------------------------- //Ejercicio 6 (primero de condiciones)
#include <stdio.h>
#include <stdlib.h>
void main()
{
int num1, num2;
printf("Ingrese el primer numero: ");
scanf("%d", &num1);
printf("Ingrese el segundo numero: ");
scanf("%d", &num2);
if (num1 > num2)
{
printf("El primer numero ingresado (%d), es mayor que el segundo numero
ingresado (%d) \n", num1, num2);
}
else
{
if (num1 == num2)
{
printf("El primer numero ingresado (%d), es igual que el segundo
numero ingresado (%d) \n", num1, num2);
}
else
{
printf("El segundo numero ingresado (%d), es mayor que el primer
numero ingresado (%d) \n", num2, num1);
}
}
system("Pause");
}
Segunda Gua Condiciones compuestas / Switch

//Ejercicio 1
#include <stdio.h>
#include <stdlib.h>
void main()
{
int n1, n2;
scanf("%d", &n1);
scanf("%d", &n2);
printf("\nEl primer numero ingresado fue: %d \nY el segundo numero ingresado
fue: %d \n \n", n1, n2);
system("Pause");
}
-----------------------------------------------------------------------------------//Ejercicio 2
#include <stdio.h>
#include <stdlib.h>
void main()
{
int fuerza, super, presion;
printf("Ingrese la superficie: ");
scanf("%d", &super);
printf("Ingrese la fuerza ejercida: ");
scanf("%d", &fuerza);
presion = fuerza / (super*super);
printf("\nLa presion total es de %d \n \n", presion);
system("Pause");
}
//Ejercicio 3
#include <stdio.h>
#include <stdlib.h>
void main()
{
int r1, r2, r3, r4, r5, rt;
printf("Ingrese el valor de R1: ");
scanf("%d", &r1);
scanf("%d", &r2);
scanf("%d", &r3);
scanf("%d", &r4);
scanf("%d", &r5);
rt = r1 + r2 + r3 + r4 + r5;
printf("\nLos valores de resistencias ingresados son:\nR1 = %d\nR2 =
%d\nR3 =
%d\nR4 = %d\nR5 = %d\nEl valor de resistencia total (Rt)
es: %d ohms. \n \n", r1, r2, r3, r4, r5, rt);
system("Pause");
}
-----------------------------------------------------------------------------------//Ejercicio 4
#include <stdio.h>
#include <stdlib.h>
void main()
{
int valor;
float octparte;
//Se crea variable de tipo float para que el programa

funcione correctamente.
printf("Ingrese el valor a dividir: ");
scanf("%d", &valor);
octparte = valor / 8;
printf("\nLa octava parte del numero ingresado es: %f \n \n", octparte);
system("Pause");
//Ejercicio 5
#include <stdio.h>
#include <stdlib.h>
void main()
{
int lado1, lado2, peri, area;
peri = (lado1 * 2) + (lado2 * 2);
area = lado1 * lado2;
printf("\nEl perimetro del rectangulo es de: %d cm. \n", peri);
printf("\nEl area del rectangulo es de: %d cm. \n \n", area);
system("Pause");
}
-----------------------------------------------------------------------------------//Ejercicio 6 (primero de condiciones)
#include <stdio.h>
#include <stdlib.h>
void main()
{
int num1, num2;
scanf("%d", &num1);
scanf("%d", &num2);
if (num1 > num2)
{
printf("\nEl primer numero ingresado (%d), es mayor que el segundo
numero ingresado (%d) \n \n", num1, num2);
}
else
{
if (num1 == num2)
{
printf("\nEl primer numero ingresado (%d), es igual que el
segundo numero ingresado (%d) \n \n", num1, num2);
}
else
{
printf("\nEl segundo numero ingresado (%d), es mayor que el
primer numero ingresado (%d) \n \n", num2, num1);
}
}
system("Pause");
}
//Ejercicio 7
#include <stdio.h>
#include <stdlib.h>
void main()
{
int edad, horas, con, sin, imp, desc;
printf("Ingrese las horas utilizadas en el servicio: ");
scanf("%d", &horas);
printf("Ingrese la edad del consumidor del servicio: ");
scanf("%d", &edad);
if (horas >= 20)
{
sin = horas * 10;
}
else
{
sin = 200;
}
if (edad >= 70)
{
desc = (sin * 50) / 100;
}
else
{
if (edad >= 60)
{
desc = (sin * 30) / 100;
}
else
{
if (edad >= 50)
{
desc = (sin * 20) / 100;
}
else
{
desc = 0;
}
}
}
sin = sin - desc;
imp = sin * 0.33;
con = sin + imp;
printf("El monto a pagar SIN impuesto es de: %d pesos. \n", sin);
printf("El monto a pagar CON impuesto es de: %d pesos. \n", con);
system("Pause");
}
//Ejercicio 8
#include <stdio.h>
#include <stdlib.h>
void main()
{
char cat;
int horas, sueldo;
printf("Por favor, ingrese las horas trabajadas: ");
printf("Ingrese la categoria del empleado <a,b,c,otro>: ");
scanf("%s", &cat);
switch (cat)
{
case 'a':
case 'A':
sueldo = horas * 20;
break;
case 'b':
case 'B':
break;
case 'c':
case 'C':
break;
default:
printf("El empleado no corresponde a ninguna categoria. \n");
}
printf("El sueldo correspondiente al empleado es de $%d pesos. \n \n",
sueldo);
system("Pause");
}
10
//Ejercicio 9
#include <stdio.h>
#include <stdlib.h>
void main()
{
int peso, alt, imc;
printf("Ingrese peso de la persona a calcular: ");
scanf("%d", &peso);
printf("Ingrese la altura: ");
scanf("%d", &alt);
imc = peso / (alt*alt);
if (imc <= 20)
{
printf("Peso bajo \n");
}
else
if (imc <= 25)
{
printf("Peso ideal \n");
}
else
{
printf("Excedido \n");
}
system("Pause");
}
------------------------------------------------------------------------------------
//Ejercicio 10
#include <stdio.h>
#include <stdlib.h>
void main()
{
int total, basico, hijos, adic1, adic2, adic3, cate;
printf("Ingrese el sueldo del empleado: $");
scanf("%d", &basico);
printf("Ingrese cantidad de hijos: ");
scanf("%d", &hijos);
printf("Ingrese la categoria: ");
scanf("%d", &cate);
adic1 = 300 * hijos;
11
if (hijos>4)
{
adic2 =
}
else
{
adic2 =
}
if (cate = 1)
{
adic3 =
}
else
if (cate = 2)
{
adic3 =
}
else
{
adic3 =
}
hijos * 200;
0;
12
(basico * 10) / 100;
(basico * 20) / 100;
0;
total = adic1 + adic2 + adic3 + basico;

printf("\nSu sueldo correspondiente es de: $%d pesos. \n \n", total);
system("Pause");
}
-----------------------------------------------------------------------------------//Ejercicio 11
#include <stdio.h>
#include <stdlib.h>
void main()
{
int n1, n2, n3;
scanf("%d", &n1);
scanf("%d", &n2);
printf("Ingrese el tercer numero: ");
scanf("%d", &n3);
if (n1 == n2 && n1 == n3)
{
printf("\nSon todos iguales \n \n");
}
else
{
if (n1 == n2 && n1 != n3)
{
printf("\n2 iguales 1 distinto \n \n");
}
else
{
if (n1 != n2 && n2 == n3)
{
}
else
{
if (n1 == n3 && n1 != n2)
{
}
else
{
printf("\nTodos distintos \n \n");
}
}
}
}
system("Pause");
}
-----------------------------------------------------------------------------------//Ejercicio 12
#include <stdio.h>
#include <stdlib.h>
void main()
{
int horas, minutos, segundos, convert, opcion;
printf("Ingrese las horas: ");
printf("Ingrese las minutos: ");
scanf("%d", &minutos);
printf("Ingrese las segundos: ");
scanf("%d", &segundos);
printf("\nElija a que va a convertir \n1: Segundos \n2: Minutos \n3: Horas
\nOtro: Muestra valor ingresado \nOpcion: ");
scanf("%d", &opcion);
switch (opcion)
{
case 1:
convert = (horas * 60) * 60 + (minutos * 60) + segundos;
printf("\nLa conversion es: %d segundos. \n", convert);
break;
case 2:
convert = (horas * 60) + (segundos / 60) + minutos;
printf("\nLa conversion es: %d minutos. \n", convert);
break;
case 3:
convert = (minutos / 60) + (segundos / 60) / 60 + horas;
printf("\na conversion es: %d horas. \n", convert);
break;
default:
printf("\nUsted ingreso: %d:%d:%d <horas, minutos, segundos> \n \n",
horas, minutos, segundos);
}
system("Pause");
}
13
//Ejercicio 13
#include <stdio.h>
#include <stdlib.h>
void main()
{
int n1, n2, n3;
scanf("%d", &n1);
scanf("%d", &n2);
printf("Ingrese el tercer numero: ");
scanf("%d", &n3);
if (n1 < n2 && n2 < n3)
{
printf("\nEl orden de los numeros es ascendente. \n\n");
}
else
{
if (n1>n2 && n2>n3)
{
printf("\nEl orden de los numeros es descendente. \n\n");
}
else
{
printf("\nLos numeros ingresados se encuentran desordenados.
\n\n");
}
}
system("Pause");
}
-----------------------------------------------------------------------------------//Ejercicio 14
#include <stdio.h>
#include <stdlib.h>
void main()
{
int sup1, pob1, sup2, pob2, sup3, pob3;
float den1, den2, den3;
printf("Ingrese la superficie de PAIS 1 en m2: ");
scanf("%d", &sup1);
scanf("%d", &sup2);
scanf("%d", &sup3);
printf("Ingrese la cantidad de poblacion de PAIS 1: ");
scanf("%d", &pob1);
scanf("%d", &pob2);
14
scanf("%d", &pob3);
den1 = pob1 / sup1;
den2 = pob2 / sup2;
den3 = pob3 / sup3;
if (den1 > den2 && den1 > den3)
{
printf("\nLa densidad de PAIS 1 es la mayor. \n \n");
}
else
{
if (den3 > den1 && den3 > den2)
{
}
else
{
}
}
system("Pause");
}
15
Tercera Gua Parte 1 Estructuras de control

//Ejercicio 1 (Guia 2)
#include <stdio.h>
#include <stdlib.h>
void main()
{
int i;
for (i = 0; i <= 9; i++)
{
printf("Valor actual de variable numeros: %d \n \n", i);
}
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 2
#include <stdio.h>
#include <stdlib.h>
void main()
{
int mayor = 0, numero = 0, i = 0;
float prom = 0;
for (i = 1; i <= 15; i++)
{
printf("%d.Ingrese un numero: ", i);
scanf("%d", &numero);
prom = prom + numero;
if (numero > mayor)
{
mayor = numero;
}
}
prom = prom / 15;
printf("\nEl promedio es de: %f \nEl mayor de los numeros ingresados es: %d
\n\n", prom, mayor);
system("Pause");
}
-----------------------------------------------------------------------//Ejercicio 3
#include <stdio.h>
#include <stdlib.h>
void main()
{
int num1, num2, i;
printf("Ingrese un numero: ");
16
scanf("%d", &num1);
printf("Ingrese otro numero: ");
scanf("%d", &num2);
printf("\nLos numeros intermedios son: \n\n");
if (num1 < num2)
{
for (i = num1 + 1; i <= num2 - 1; i++)
{
printf("%d\n", i);
}
printf("\nLa escala es ascendente \n\n");
}
else
{
for (i = num1 - 1; i >= num2 + 1; i--)
{
printf("%d\n", i);
}
printf("\nLa escala es descendente \n\n");
}
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 4
#include <stdio.h>
#include <stdlib.h>
void main()
{
int numero = 0, i = 0;
long int factorial = 1;
printf("Ingrese un numero para mostrar sus factoriales: ");
if (numero > 0)
{
printf("\n%d!: ", numero);
for (i = numero; i >= 2; i--)
{
printf("%d x ", i);
factorial = factorial * i;
if (i == 2)
{
printf("1");
}
}
printf("\nFactorial: %lu", factorial);
//Como usamos una variable de
tipo LONG INT usamos %lu para mostrar el valor de la variable LONG INT
UNSIGNED
}
else
if (numero == 0)
{
printf("1");
17
factorial = 1;
printf("\nFactorial: %d", factorial);
}
else
{
printf("\nERROR: El numero es menor a 0.\a");
}
printf("\n\n");
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 5
#include <stdio.h>
#include <stdlib.h>
void main()
{
int base = 0, i = 1, potencia = 0, total = 1;
printf("Ingrese la base: ");
scanf("%d", &base);
printf("Ingrese la potencia: ");
scanf("%d", &potencia);
printf("\n%d elevado a la %d: ", base, potencia);
for (i = potencia; i >= 1; i--)
{
if (i != 1)
{
printf("%d x ", base);
total = total*base;
}
else
{
printf("%d", base);
total = total*base;
}
}
printf("\n\nResultado: %d\n\n", total);
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 6
#include <stdio.h>
#include <stdlib.h>
void main()
{
int alumno = 0, i = 0, numNota = 0, calific;
float promAlum = 0.0, promCurso = 0.0, promParcial = 0.0;
for (i = 1; i <= 30; i = i)
18
{
numNota = numNota++;
printf("Ingrese nota %d de alumno %d: ", numNota, i);
scanf("%d", &calific);
if (calific >= 0 && calific <= 10)
//Mientras la nota sea de 0 a 10
{
promParcial = promParcial + calific;
promCurso = promCurso + calific;
promAlum = promParcial / 10;
if (numNota == 10)
{
promParcial = 0;
printf("\nPromedio de alumno %d es de: %f \n\n", i,
promAlum);
numNota = 0;
i = i + 1;
}
}
else
{
//Al ingresar valor fuera del rango 0-10
printf("----------------------------------------\nINGRESO VALOR
INCORRECTO (Solo numeros de 0 a 10). \n\aPor favor, ingrese
nuevamente:\n----------------------------------------\n");
numNota--;
calific = 0;
}
}
promCurso = promCurso / 300;
printf("\nPromedio general del curso: %f\n\n", promCurso);
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 7
#include <stdio.h>
#include <stdlib.h>
void main()
{
int dia = 1, i = 0, totXvend = 0, uniVend = 0, totalVentas = 0, mayorVenta =
0, mejorVendedor = 0;
for (i = 1; i <= 20; i++)
{
printf("Vendedor numero %d: \n\n", i);
while (dia <= 15)
{
printf("Dia %d: Ingrese productos vendidos: ", dia);
scanf("%d", &uniVend);
dia++;
totXvend = totXvend + uniVend;
}
if (mayorVenta < totXvend)
{
mayorVenta = totXvend;
19
mejorVendedor = i;
}
printf("\nEl vendedor N:%d vendio un total de %d unidades en un periodo
de 15 dias.\n", i, totXvend);
printf(" \n-----------------------------------\n\n");
totalVentas = totalVentas + totXvend;
dia = 1;
uniVend = 0;
totXvend = 0;
}
printf("El total de unidades vendidas es de: %d. \n", totalVentas);
printf("El vendedor con mayor numero de ventas es el vendedor N:%d con un
total de: %d unidades vendidas.\n\n", mejorVendedor, mayorVenta);
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 8
#include <stdio.h>
#include <stdlib.h>
void main()
{
int numero = 0, i = 0, positivos = 0, negativos = 0, nulos = 0;
for (i = 1; i <= 10; i++)
{
printf("%d. Ingrese un numero para su comprobacion: ", i);
if (numero > 0)
{
positivos++;
}
else
{
if (numero == 0)
{
nulos++;
}
else
{
negativos++;
}
}
}
printf("\nResultados: \n\nPositivos: %d/10\nNegativos: %d/10\nIguales a cero:
%d/10\n\n", positivos, negativos, nulos);
system("Pause");
}
20
//Ejercicio 9
#include <stdio.h>
#include <stdlib.h>
void main()
{
int sueldo = 0, i = 0, demas = 0, demenos = 0, igual = 0, empleado = 1;
for (i = 1; i <= 20; i++)
{
printf("%d. Ingrese el sueldo del empleado %d: ", i, empleado);
scanf("%d", &sueldo);
if (sueldo >= 0)
{
empleado++;
if (sueldo > 2000)
{
demas++;
}
else
{
if (sueldo == 2000)
{
igual++;
}
else
{
demenos++;
}
}
}
else
{
printf("**************************************************\nINGRESO VALOR
INCORRECTO(Solo valores mayores a $0) \n\aPor favor, intente nuevamente:
\n**************************************************\n");
i--;
}
}
printf("\nResultados: \n\nGanan mas de $2000 pesos: %d/20\nGanan $2000 pesos:
%d/20\nMenos de $2000 pesos: %d/20\n\n", demas, igual, demenos);
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 10
#include <stdio.h>
#include <stdlib.h>
void main()
{
int i = 0;
char nombre[50];
char apelli[50];
float nota = 0.0;
21
for (i = 0; i <= 5; i++)

{
printf("Ingrese el nombre y apellido del alumno: ");
scanf("%s", nombre);
scanf("%s", apelli);
printf("Ingrese la nota de %s: ", nombre);
scanf("%f", &nota);
if (nota >= 0 && nota <= 10)
{
if (nota > 8)
{
printf("\nEl alumno %s %s tiene nota mayor a 8.\n\n",
nombre, apelli);
nota = 0;
}
else
{
printf("\nEl alumno %s %s no tiene una nota mayor a
8.\n\n", nombre, apelli);
nota = 0;
}
}
else
{
printf("\nERROR: La nota ingresada no pertenece al rango 010.\n\n");
i--;
nota = 0;
}
}
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 11
#include <stdio.h>
#include <stdlib.h>
void main()
{
int dia, mes, ao, bisiesto;
printf("Ingrese un numero de dia: ");
scanf("%d", &dia);
printf("Ingrese un numero de mes: ");
scanf("%d", &mes);
printf("Ingrese un numero de a\xA4o: ");
scanf("%d", &ao);
22
if (ao > 0 && (mes > 0 && mes <= 12))

{
switch (mes)
{
//Para meses de 31 dias
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
if (dia > 0 && dia <= 31)
{
printf("\nLa fecha ingresada es valida.\n\n");
}
else
{
printf("\nERROR: La fecha ingresada es invalida.\a\n\n");
}
break;
case 2:
//Especial para mes de febrero
bisiesto = ao % 4;
if (dia == 29)
{
if (bisiesto == 0)
{
printf("\nLa fecha ingresada es valida.\n\n",
ao);
}
else
{
printf("\nERROR: La fecha ingresada es
invalida.\a\n\n");
}
}
else
{
if (dia > 0 && dia < 29)
{
}
}
break;
case 4:
case 6:
case 9:
case 11:
if (dia > 0 && dia <= 30)
{
}
else
{
}
break;
23
}
}
else
{
//Finaliza instruccion SWITCH

//Finaliza primer instruccion IF

}
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 12
#include <stdio.h>
#include <stdlib.h>
void main()
{
int nroFact = 0, nroProd = 0, cant = 0, masVend = 0, mayorImp = 0, i = 0;
float precio = 0.0, importe = 0.0;
while (nroProd != 999)
{
printf("Ingrese el numero de producto: ");
scanf("%d", &nroProd);
if (nroProd != 999)
{
printf("Ingrese numero de factura: ");
scanf("%d", &nroFact);
printf("Ingrese cantidad de productos: ");
scanf("%d", &cant);
if (cant > masVend)
{
masVend = nroProd;
}
printf("Ingrese precio unitario de producto: ");
scanf("%f", &precio);
importe = precio * cant;
if (importe > mayorImp)
{
mayorImp = nroProd;
}
printf("\n");
}
else
{
printf("\nEl producto mas vendido es el: %d\n", masVend);
printf("\nEl producto de mayor importe vendido es el: %d\n\n",
mayorImp);
break;
}
}
system("Pause");
}
------------------------------------------------------------------------ -
24
//Ejercicio 13
#include <stdio.h>
#include <stdlib.h>
void main()
{
int alumno = 0, i = 1, mayorProm = 0, TPaprob = 0, alumINSUF = 0, numACT = 1,
mejorProm = 0;
float promParcial = 0.0, promGeneral = 0.0, promCurso = 0.0, notaTP = 0.0,
notaAct = 0.0;
for (i = 1; i <= 50; i++)
{
printf("Numero de alumno: %d\n\n", i);
printf("Actividad: TP - Ingrese nota de Trabajo Practico: ");
scanf("%f", &notaTP);
if (notaTP < 0 || notaTP > 10)
{
printf("**************************************************\nINGRESO
VALOR INCORRECTO (Solo numeros de 0 a 10) \n\aPor favor, intente
nuevamente:\n**************************************************\n");
notaTP = 0;
i--;
}
else
//Si se encuentra dentro del rango 0-10
{
printf("\nIngrese numero NEGATIVO para finalizar ingreso.\n");
while (notaAct >= 0 && notaAct <= 10)
{
printf("Actividad: %d - Ingrese nota de actividad: ",
numACT);
scanf("%f", &notaAct);
numACT++;
promParcial = promParcial + notaAct;
if (notaAct > 10)
{
printf("*************************************************
*\nINGRESO VALOR INCORRECTO (Solo numeros de 0 a 10)
\n\aPor favor, intente
nuevamente:\n********************************************
******\n");
numACT--;
promParcial = promParcial - (notaAct);
notaAct = 0;
}
}
numACT--;
if (numACT <= 3)
{
alumINSUF++;
}
promGeneral = (promParcial + notaTP) / (numACT);
printf("\nPromedio de alumno: %.2f\n\n---------------------------------------\n", promGeneral);
25
//Cuando el promedio es el mas alto se almacena el numero de

alumno
if (promGeneral > mayorProm)
{
mayorProm = promGeneral;
mejorProm = i;
}
//Si la nota de TP es mayor o igual a 6, se aumenta en 1 la
variable correspondiente
if (notaTP >= 6)
{
TPaprob++;
}
//Se resetean las variables para su nuevo uso y se actualiza el
valor del promCurso para su posterior division entre cantidad de
alumnos
notaAct = 0;
notaTP = 0;
numACT = 1;
promParcial = 0;
promCurso = promCurso + promGeneral;
promGeneral = 0;
numACT = 1;
notaAct = 0;
}
printf("\n");
}
printf("Numero de alumno con mejor promedio: %d\n", mejorProm);
printf("Promedio total del curso: %.2f \n", promCurso);
printf("Alumnos con 2 o menos actividades registradas: %d \n", alumINSUF);
printf("Alumnos con TP aprob: %d \n\n", TPaprob);
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 15
#include <stdio.h>
#include <stdlib.h>
main()
{
int i = 0, cont = 0, numero = 0;
int unsigned long fctrial = 1;
for (cont = 1; cont <= 1; cont++)
{
printf("Ingrese un numero (ENTERO) para hallar sus factoriales: ");
if (numero >= 0)
{
if (numero == 0 || numero == 1)
{
printf("\nEl factorial de %d es: 1", numero);
}
if (numero >= 0)
{
26

{
printf("%d x ", i);
fctrial = fctrial * i;
if (i == 2)
{
printf("1\n");
}
}
printf("El factorial de %d es: %lu\n\n", numero,
fctrial);
}
}
else
{
printf("\n<<Ingreso un valor no valido, solo numeros MAYORES o
IGUALES a 0>>\n\n");
cont--;
}
}
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 16
#include <stdio.h>
#include <stdlib.h>
main()
{
int numero = 0, i = 0, result = 0;
printf("Ingrese un numero para mostrar su tabla de multiplicar: ");
for (i = 0; i <= 10; i++)
{
result = numero * i;
printf("\n%d x %d = %d", numero, i, result);
}
printf("\n\n");
system("Pause");
}
27
//Ejercicio 17
#include <stdio.h>
#include <stdlib.h>
void main()
{
int limit1 = 0, limit2 = 0, suma = 0, i = 0, cont = 0, cumpleCond = 0,
restoCero = 0;
printf("Ingrese el limite mas bajo <ENTERO>: ");
scanf("%d", &limit1);
{
printf("Ingrese el limite mas alto <ENTERO>: ");
if (limit2 <= limit1)
{
printf("\nERROR: Ha ingresado un valor menor o igual al limite
mas bajo.");
cont--;
}
printf("\n");
for (i = limit1; i <= limit2; i++)
{
restoCero = i % 5;
if (restoCero == 0)
{
suma = suma + i;
printf("%d", i);
if (i < limit2)
{
printf(" + ");
}
}
}
if (suma != 0)
{
printf("\n\nLa suma de los multiplos de 5 entre %d y %d es:
%d\n\n", limit1, limit2, suma);
}
else
{
printf("\nNo hay numeros en el rango %d / %d que sean multiplos
de 5. SUMA = 0\n\n", limit1, limit2);
}
}
system("Pause");
}
28
//Ejercicio 18
#include <stdio.h>
#include <stdlib.h>
main()
{
int num1 = 0, num2 = 0, i = 0, result = 0, cont = 0;
{
printf("Ingrese un factor <ENTERO POSITIVO>: ");
scanf("%d", &num1);
if (num1 < 0)
{
printf("ERROR: Ingreso un valor incorrecto ");
cont--;
}
printf("Ingrese el segundo factor <ENTERO POSITIVO>: ");
scanf("%d", &num2);
if (num2 < 0)
{
cont--;
}
for (i = 1; i <= num2; i++)
{
result = result + num1;
printf("%d", num1);
if (i < num2)
{
printf(" + ");
}
}
}
printf("\n\nEl producto de %d y %d sin usar la operacion <*> es: %d\n\n",
num1, num2, result);
system("Pause");
}
------------------------------------------------------------------------ -
//Ejercicio 19
#include <stdio.h>
#include <stdlib.h>
Void main()
{
int num1 = 0, num2 = 0, i = 0, result = 0, cont = 0, valorTotal = 0;
{
printf("Ingrese el dividendo <ENTERO POSITIVO>: ");
scanf("%d", &num1);
if (num1 < 0)
29
{
cont--;
}
printf("Ingrese el divisor <ENTERO POSITIVO>: ");
scanf("%d", &num2);
if (num2 < 0)
{
cont--;
}
result = num1;
if (num1 > num2)
{
do
{
result = result - num2;
valorTotal++;
} while (result >= num2);
}
else
{
printf("\nEl primer valor debe ser mayor que el segundo
obligatoriamente: \n\n");
cont--;
}
}
printf("\nLa division entre %d y %d sin usar la operacion </> es: %d \nCon un
resto igual a: %d\n\n", num1, num2, valorTotal, result);
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 20
#include <stdio.h>
#include <stdlib.h>
Void main()
{
int num1 = 0, num2 = 0, i = 0, result = 0, cont = 0, valorTotal = 0;
{
scanf("%d", &num1);
if (num1 < 0)
{
cont--;
}
scanf("%d", &num2);
if (num2 < 0)
{
30
cont--;
}
result = num1;
if (num1 > num2)
{
do
{
result = result - num2;
valorTotal++;
} while (result >= num2);
}
else
{
cont--;
}
}
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 21
#include <stdio.h>
#include <stdlib.h>
main()
{
int anio = 0, cont = 0, resto = 0;
printf("<<ADVERTENCIA: Si ingresa un numero negativo sera usado como anios
a.C.>>\n\n");
{
printf("Ingrese un anio distinto de 0: ");
scanf("%d", &anio);
if (anio < 0)
{
anio = anio*(-1);
}
if (anio == 0)
{
printf("\n<<ERROR: Le dije que ingresara un valor distinto de 0
:@ >>\n\n");
cont--;
}
if (anio > 0)
{
resto = anio % 4;
if (resto == 0)
{
resto = 0;
resto = anio % 100;
31
if (resto == 0)
{
resto = 0;
resto = anio % 400;
if (resto == 0)
{
printf("\nEl anio ingresado SI es
bisiesto.\n\n");
}
else
{
printf("\nEl anio ingresado NO es
bisiesto.\n\n");
}
}
else
{
printf("\nEl anio ingresado SI es bisiesto.\n\n");
}
}
else
{
printf("\nEl anio ingresado NO es bisiesto.\n\n");
}
}
}
system("Pause");
}
------------------------------------------------------------------------ -
//Ejercicio 22
#include <stdio.h>
#include <stdlib.h>
void main()
{
int num = 0, uniMil = 0, cent = 0, dece = 0, uni = 0, inicial = 0, capicua =
0;
scanf("%d", &num);
inicial = num;
uniMil = num / 1000;
num = num - (1000 * uniMil);
cent = num / 100;
num = num - (100 * cent);
dece = num / 10;
num = num - (10 * dece);
uni = inicial - (1000 * uniMil) - (cent * 100) - (dece * 10);
capicua = uniMil + (1000 * uni) + (dece * 100) + (cent * 10);
if (capicua == inicial)
{
printf("El numero SI es capicua\n");
}
32
else
{
printf("El numero NO es capicua\n");
}
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 23
#include <stdio.h>
#include <stdlib.h>
main()
{
int uni = 0, dec = 0, cent = 0, uniMil = 0, decMil = 0, centMil = 0, i = 0;
long int num = 0, copia = 0;
printf("Ingrese un numero de 6 cifras <<dd-mm-aa>>: ");
scanf("%d", &num);
copia = num;
if (num >= 100000)
{
centMil = num / 100000;
num = num - (100000 * centMil);
}
decMil = num / 10000;
num = num - (10000 * decMil);
cent = num / 100;
dec = num / 10;
num = num - (10 * dec);
uni = copia - (100000 * centMil) - (10000 * decMil) - (1000 * uniMil) - (cent
* 100) - (dec * 10);
printf("\nDia: %d%d", centMil, decMil);
printf("\nMes: %d%d", uniMil, cent);
printf("\nA\xA4o: %d%d\n\n", dec, uni);
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 24
#include <stdio.h>
#include <stdlib.h>
Void main()
{
int num = 0, i = 0, division = 0, suma = 0;
printf("Ingrese un numero para su verificacion: ");
scanf("%d", &num);
for (i = num - 1; i >= 1; i--)
{
33
division = num % i;
if (division == 0)
{
suma = suma + i;
}
}
if (suma == num)
{
printf("\nEl numero ingresado SI es perfecto.\n\n");
}
else
{
printf("\nEl numero ingresado NO es perfecto.\n\n");
}
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 25
#include <stdio.h>
#include <stdlib.h>
void main()
{
int P = 0, Q = 0, i = 0, PmenosQ = 0, cont = 0;
int long unsigned factorialA = 1, factorialB = 1;
float result = 0.0;
{
printf("Ingrese el valor de P: ");
scanf("%d", &P);
printf("Ingrese el valor de Q: ");
scanf("%d", &Q);
if (P >= 0)
{
for (i = P; i >= 1; i--)
{
factorialA = factorialA * i;
}
if (P == 0)
{
factorialA = 1;
}
i = 0;
PmenosQ = P - Q;
if (PmenosQ >= 0)
{
for (i = PmenosQ; i >= 1; i--)
{
factorialB = factorialB * i;
}
result = factorialA / (factorialB * Q);
printf("El resultado es: %.2f\n\n", result);
34
}
else
{
printf("\nERROR: No se pudo calcular el factorial de P Q , la resta da un numero negativo, intente
nuevamente:\n\n");
cont--;
}
}
else
{
35
printf("\nERROR: P no puede valer menos que 0, intente

nuevamente:\n\n");
cont--;
}
}
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 26
#include <stdio.h>
#include <stdlib.h>
void main()
{
int varA = 0, varB = 1, i = 0, limite = 0, cont = 0, secue = 1, cuentaComa =
0;
{
printf("Ingrese un limite para mostrar la secuencia de Fibonacci: ");
scanf("%d", &limite);
printf("\nLa secuencia de Fibonacci es la siguiente: ");
if (limite > 0)
{
for (i = 1; i <= limite; i++)
{
secue = varA + varB;
printf("%d", secue);
if (i < limite)
{
printf(", ");
}
varB = varA;
varA = secue;
}
}
else
{
printf("\nERROR: Ha ingresado un valor igual o menor a 0, por
favor intente nuevamente:\n\n");
cont--;
}
}
printf("\n\n");
system("Pause");
}
------------------------------------------------------------------------ // Ejercicio 27
#include <stdio.h>
#include <stdlib.h>
void main()
{
int num = 0, i = 0, j = 0, k = 0;
scanf("%d", &num);
printf("\n");
for (i = 0; i <= num; i++)
{
for (k = num - 1; k >= i; k--)
{
printf(" ");
}
for (j = 0; j <= i * 2; j++)
{
printf("*");
}
printf("\n");
}
printf("\n");
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 28
#include <stdio.h>
#include <stdlib.h>
void main()
{
int dia = 0, mes = 0, i = 0;
for (i = 1; i <= 1; i++)
{
printf("Ingrese un dia: ");
scanf("%d", &dia);
printf("Ingrese un mes: ");
scanf("%d", &mes);
if ((dia >= 1 && dia <= 31) && (mes >= 1 && mes <= 12))
{
if (dia >= 21 && mes == 1 || dia <= 18 && mes == 2)
{
printf("\nEl signo correspondiente a la fecha es:
ACUARIO.\n\n");
}
36
if (dia >= 19 && mes == 2 || dia <= 20 && mes == 3)

{
PISCIS.\n\n");
}
if (dia >= 21 && mes == 3 || dia <= 20 && mes == 4)
{
ARIES.\n\n");
}
if (dia >= 21 && mes == 4 || dia <= 21 && mes == 5)
{
TAURO.\n\n");
}
if (dia >= 22 && mes == 5 || dia <= 21 && mes == 6)
{
GEMINIS.\n\n");
}
if (dia >= 22 && mes == 6 || dia <= 22 && mes == 7)
{
CANCER.\n\n");
}
if (dia >= 23 && mes == 7 || dia <= 23 && mes == 8)
{
LEO.\n\n");
}
if (dia >= 24 && mes == 8 || dia <= 23 && mes == 9)
{
VIRGO.\n\n");
}
if (dia >= 24 && mes == 9 || dia <= 23 && mes == 10)
{
LIBRA.\n\n");
}
if (dia >= 24 && mes == 10 || dia <= 22 && mes == 11)
{
ESCORPIO.\n\n");
}
if (dia >= 23 && mes == 11 || dia <= 21 && mes == 12)
{
SAGITARIO.\n\n");
}
if (dia >= 22 && mes == 12 || dia <= 20 && mes == 1)
{
CAPRICORNIO.\n\n");
}
}
else
{
37
printf("\nERROR: Ha ingresado una fecha invalida, intente

nuevamente:\n\n");
i--;
}
}
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 29
#include <stdio.h>
#include <stdlib.h>
void main()
{
float importe = 0.0, efectivo = 0.0, vuelto = 0.0;
int i = 0;
printf("BIENVENIDO AL SUPERCHINO...\n\n");
for (i = 1; i <= 1; i++)
{
printf("Ingrese el monto a pagar: ");
scanf("%f", &importe);
printf("Ingrese el monto recibido del cliente: ");
scanf("%f", &efectivo);
if (efectivo >= importe)
{
vuelto = efectivo - importe;
printf("\nEl vuelto es: %.2f pesos.\n\n", vuelto);
}
else
{
printf("\nERROR: Ha ingresado un monto recibido del cliente
menor al importe o...\n");
printf("ADVERTENCIA: Lo quieren estafar... Ingrese nuevamente
ambos valores:\n\n");
i--;
}
}
system("Pause");
}
------------------------------------------------------------------------ //Ejercicio 30
#include <stdio.h>
#include <stdlib.h>
void main()
{
int num1 = 0, num2 = 0, desorden = 0, ascCont = 1, desCont = 1, canti = 0,
i=1, primerNum = 0, ultNum = 0, suma = 0;
printf("Ingrese la cantidad de numero a ingresar: ");
38
scanf("%d", &canti);
scanf("%d", &num1);
primerNum = num1;
for (i = 1; i <= canti - 1; i++)
{
scanf("%d", &num2);
if (num2 > num1)
{
ascCont++;
num1 = num2;
}
if (num2 < num1)
{
desCont++;
num1 = num2;
}
else
{
desorden++;
}
if (i == canti - 1)
{
ultNum = num2;
suma = primerNum + ultNum;
}
}
if (ascCont == i)
{
printf("\nORDEN: ASCENDENTE\n\n");
}
else
{
if (desCont == i)
{
printf("\nORDEN: DESCENDENTE\n\n");
}
else
{
printf("\nORDEN: DESORDENADOS\n\n");
}
}
printf("La suma entre el primer y ultimo numero ingresado es: %d\n\n", suma);
system("Pause");
}
39
//Ejercicio 31
#include <stdio.h>
#include <stdlib.h>
void main()
{
//Variables del programa Fibonacci
int varA = 0, varB = 1, i = 0, limite = 0, contFibo = 0, contPpal = 0, secue
= 1, cuentaComa = 0;
//Variable del MENU
int opcion = 0;
//Variables programa Factoriales
int numero = 0, iFact = 0, contFact = 0;
for (contPpal = 1; contPpal <= 1; contPpal++)

{
printf("MENU:\n\n");
printf("1: Salir\n2: Mostrar secuencia de Fibonacci\n3: Calculadora de
Factoriales\n\nIngrese una opcion: ");
switch (opcion)
{
case 1:
break;
case 2:
printf("--------------------------------");
printf("\nSECUENCIA DE FIBONACCI:\n\n");
for (contFibo = 1; contFibo <= 1; contFibo++)
{
printf("Ingrese un limite para mostrar la secuencia de
Fibonacci: ");
if (limite > 0)
{
{
if (i < limite)
{
printf(", ");
}
varB = varA;
varA = secue;
}
}
else
{
printf("\nERROR: Ha ingresado un valor igual o
menor a 0, por favor intente nuevamente:\n\n");
contFibo--;
}
}
40
printf("\n\n");
printf("--------------------------------\n\n");
contPpal--;
break;
case 3:
printf("--------------------------------");
printf("\nCALCULADORA DE FACTORIAL:\n\n");
for (contFact = 1; contFact <= 1; contFact++)
{
printf("Ingrese un numero para mostrar sus factoriales:
");
if (numero > 0)
{
for (iFact = numero; iFact >= 2; iFact--)
{
printf("%d x ", iFact);
factorial = factorial * iFact;
if (iFact == 2)
{
printf("1");
}
}
}
else
if (numero == 0)
{
printf("1");
factorial = 1;
}
else
{
contFact--;
}
printf("\n\n");
}
contPpal--;
printf("--------------------------------\n\n");
break;
default:
contPpal--;
printf("\aERROR: Ha ingresado un valor incorrecto, intente
nuevamente: \n\n");
printf("--------------------------------\n\n");
}
}
}
41
//Ejercicio 32
#include <stdio.h>
#include <stdlib.h>
void main()
{
float porcen1 = 0, porcen2 = 0, porcen3 = 0;
int opcion = 0;
int cantPers = 0;
int prod1 = 0, prod2 = 0, prodAmbos = 0;
printf("Opciones:\n\n");
printf("1: Producto N%c1\n", 167);
printf("Otro: Ambos productos\n\n");
printf("Numero negativo: Para finalizar ingreso. \n\n");
while (opcion >= 0)
{
cantPers++;
printf("Opcion: ");
switch (opcion)
{
case 1:
prod1++;
break;
case 0:
prod2++;
break;
}
if (opcion > 0 && opcion != 1 && opcion != 0)
{
prodAmbos++;
}
}
if (cantPers != 0)
{
cantPers--;
porcen1 = (prod1 * 100) / cantPers;
porcen2 = (prod2 * 100) / cantPers;
porcen3 = (prodAmbos * 100) / cantPers;
}
system("cls");
printf("Cantidad de personas entrevistadas: %d\n\n", cantPers);
printf("Porcentaje de personas que eligio el producto 1: %.2f\n", porcen1);
printf("Porcentaje de personas que eligio el producto 2: %.2f\n\n", porcen2);
printf("Porcentaje de personas que eligio ambos productos: %.2f\n\n",
porcen3);
system("Pause");
}
42
Tercera Gua Parte 1 (Funciones) Estructuras de control

//Ejercicio 2 (Funciones)
#include <stdio.h>
#include <stdlib.h>
float promedio(int numero, float prom)
{
prom = prom + numero; //a prom le suma nmero
return prom;//devuelve prom
}
int mayorProm(int numero, int mayor)//Recibe dos valores desde la funcin principal
{
if (numero > mayor) //compara los valores que recibe
{
mayor = numero;
}
return mayor; //devuelve el valor resultante!
}
void main()
{
float prom = 0;
int numero = 0, mayor = 0;
int i = 0;
for (i = 1; i <= 5; i++)
{
printf("%d. Ingrese el valor de nota: ", i);
prom = promedio(numero, prom);
mayor = mayorProm(numero, mayor);
prom = prom / 5;
printf("\nEl promedio es de: %.2f \nEl mayor de los numeros ingresados es: %d
\n\n", prom, mayor);
system("Pause");
}
-----------------------------------------------------------------------------------//Ejercicio 3
#include <stdio.h>
#include <stdlib.h>
void num1Mayor(int num1, int num2)
{
int i = 0;
for (i = num1 + 1; i <= num2 - 1; i++)
{
printf("%d\n", i);
}
printf("\nLa escala es ascendente.\n\n");
}
43
void num2Mayor(int num1, int num2)

{
int i = 0;
for (i = num1 - 1; i >= num2 + 1; i--)
{
printf("%d\n", i);
}
printf("\nLa escala es descendente.\n\n");
}
void main()
{
int num1 = 0, num2 = 0, i = 0;
scanf("%d", &num1);
printf("Ingrese otro numero: ");
scanf("%d", &num2);
printf("\nLos numeros intermedios son: \n\n");
if (num1 == num2)
{
printf("\aNO SE PUEDE BUSCAR NUMEROS INTERMEDIOS ENTEROS ENTRE EL MISMO
NUMERO\n\n");
}
if (num1 < num2)
{
num1Mayor(num1, num2);
}
else
{
if (num2 < num1)
{
num2Mayor(num1, num2);
}
}
system("Pause");
}
-----------------------------------------------------------------------------------//Ejercicio 4
#include <stdio.h>
#include <stdlib.h>
long int funcFactorial(int numero)
{
int i = 0;
{
printf("%d x ", i);
factorial = factorial * i;
if (i == 2)
{
printf("1");
}
}
44
return factorial;
}
void main()
{
int numero = 0;
if (numero > 0)
{
printf("\nFactorial: %lu\n\n", funcFactorial(numero));
}
else
{
if (numero == 0)
{
printf("\nFactorial: %d", funcFactorial(numero));
}
else
{
printf("\ERROR: El numero es menor a 0.\a");
}
printf("\n\n");
}
system("Pause");
}
-----------------------------------------------------------------------------------//Ejercicio 5
#include <stdio.h>
#include <stdlib.h>
long int funcTotal(int base, int potencia)
{
long int total = 1, i = 0;
for (i = potencia; i >= 1; i--)
{
if (i != 1)
{
printf("%d x ", base);
total = total*base;
}
else
{
printf("%d", base);
total = total*base;
}
}
return total;
}
void main()
{
int base = 0, potencia = 0;
printf("Ingrese la base: ");
scanf("%d", &base);
45
printf("Ingrese la potencia: ");

scanf("%d", &potencia);
printf("\n%d elevado a la %d: ", base, potencia);
printf("\n\nResultado: %lu\n\n", funcTotal(base, potencia));
system("Pause");
}
------------------------------------------------------------------------------------------------------//Ejercicio 6
#include <stdio.h>
#include <stdlib.h>
float funcPromParcial(int calific, float promParcial)
{
return promParcial;
}
void main()
{
int numNota = 0, calific = 0, i = 0;
float promAlum = 0.0, promParcial = 0.0, promCurso = 0.0, promedioAlumno = 0;
for (i = 1; i <= 4; i++)
{
for (numNota = 1; numNota <= 3; numNota++)
{
printf("Ingrese nota %d de alumno %d: ", numNota, i);
{
promedioAlumno = funcPromParcial(calific, promParcial);
if (numNota == 3)
{
promParcial = 0;
printf("\nPromedio de alumno %d es de: %.2f \n\n",
i, promedioAlumno);
numNota = 0;
break;
}
}
else
{
printf("\nINGRESO VALOR INCORRECTO (Solo numeros de 0 a
10). \n\aPor favor, ingrese nuevamente:\n\n");
numNota--;
calific = 0;
}
}
}
printf("El promedio del curso es: %.2f\n\n", promCurso);
system("Pause");
}
46
-----------------------------------------------------------------------------------//Ejercicio 7
#include <stdio.h>
#include <stdlib.h>
int funcVentasTotales(int totXvend)
{
int totalVentas = 0;
totalVentas = totalVentas + totXvend;
return totalVentas;
}
int funcMejorVend(int mejorVendedor, int i, int totXvend, int mayorVenta)
{
if (mayorVenta < totXvend)
{
mayorVenta = totXvend;
mejorVendedor = i;
}
return mejorVendedor;
//No funca
}
void main()
{
int dia = 1, i = 0, totXvend = 0, uniVend = 0, mejorVendedor = 0,
ventasTotales = 0, mayorVenta = 0;
for (i = 1; i <= 3; i++)
{
printf("Vendedor numero %d: \n\n", i);
while (dia <= 5)
{
printf("Dia %d: Ingrese productos vendidos: ", dia);
scanf("%d", &uniVend);
dia++;
totXvend = totXvend + uniVend;
}
mejorVendedor = funcMejorVend(mejorVendedor, i, totXvend, mayorVenta);
printf("\nEl vendedor N:%d vendio un total de %d unidades en un periodo
de 15 dias.\n", i, totXvend);
printf(" \n-----------------------------------\n\n");
ventasTotales = funcVentasTotales(totXvend);
dia = 1;
uniVend = 0;
totXvend = 0;
}
printf("El total de unidades vendidas es de: %d. \n", ventasTotales);
printf("El vendedor con mayor numero de ventas es el vendedor N:%d\n\n",
mejorVendedor);
system("Pause");
}
47
//Ejercicio 8
#include <stdio.h>
#include <stdlib.h>
int func_positivos(int numero)
{
int positivos = 0;
positivos++;
return positivos;
}
int func_negativos(int numero)
{
int negativos = 0;
negativos++;
return negativos;
}
int func_nulos(int numero)
{
int nulos = 0;
nulos++;
return nulos;
}
void main()
{
int numero = 0, i = 0;
int pos = 0, nega = 0, null = 0;
for (i = 1; i <= 10; i++)
{
if (numero > 0)
{
pos = func_positivos(numero);
}
else
{
if (numero < 0)
{
nega = func_negativos(numero);
}
else
{
null = func_nulos(numero);
}
}
}
%d/10\n\n", pos, nega, null);
system("Pause");
}
48
//Ejercicio 8 (Modificado)
#include <stdio.h>
#include <stdlib.h>
void func_Compr(int *po, int *nu, int *ne, int numero)
{
if (numero > 0)
{
*po = *po + 1;
}
else
{
if (numero == 0)
{
*nu = *nu + 1;
}
else
{
*ne = *ne + 1;
}
}
}
void main()
{
int i = 0, numero = 0, positivos = 0, negativos = 0, nulos = 0;
for (i = 1; i <= 10; i++)
{
func_Compr(&positivos, &nulos, &negativos, numero);
}
%d/10\n\n", positivos, negativos, nulos);
system("Pause");
}
-----------------------------------------------------------------------------------//Ejercicio 9
#include <stdio.h>
#include <stdlib.h>
int demas = 0, demenos = 0, igual = 0;
void func_Compr(int sueldo, int empleado)
{
empleado++;
if (sueldo > 2000)
{
demas++;
}
else
{
if (sueldo == 2000)
{
igual++;
}
49
else
{
demenos++;
}
}
}
void main()
{
int sueldo = 0, i = 0, empleado = 1;
for (i = 1; i <= 6; i++)
{
printf("%d. Ingrese el sueldo del empleado %d: ", i, empleado);
scanf("%d", &sueldo);
if (sueldo >= 0)
{
func_Compr(sueldo, empleado);
}
else
{
printf("\nINGRESO VALOR INCORRECTO(Solo valores mayores a $0) \n\aPor
favor, intente nuevamente: \n\n");
i--;
}
}
%d/20\nMenos de $2000 pesos: %d/20\n\n", demas, igual, demenos);
system("Pause");
}
//Ejercicio 10
#include <stdio.h>
#include <stdlib.h>
void func_ComprNota(float nota, char nombre, char apelli, int i)
{
if (nota >= 0 && nota <= 10)
{
if (nota > 8)
{
printf("\nEl alumno %s %s tiene nota mayor a 8.\n\n", nombre,
apelli);
nota = 0;
}
else
{
printf("\nEl alumno %s %s no tiene una nota mayor a 8.\n\n",
nombre, apelli);
nota = 0;
}
}
else
{
printf("\nERROR: La nota ingresada no pertenece al rango 0-10.\n\n");
i--;
nota = 0;
}
}
50
void main()
{
int i = 0;
char nombre[50];
char apelli[50];
float nota = 0.0;
for (i = 0; i <= 5; i++)
{
printf("Ingrese el nombre y apellido del alumno: ");
scanf("%s", &nombre);
scanf("%s", &apelli);
printf("Ingrese la nota de %s: ", nombre);
scanf("%f", &nota);
func_ComprNota(nota, nombre[50], apelli[50], i);
}
system("Pause");
}
-----------------------------------------------------------------------------------//Ejercicio 11
#include <stdio.h>
#include <stdlib.h>
void func_ComprFecha(int dia, int mes, int ao, int bisiesto)
{
switch (mes)
{
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
if (dia > 0 && dia <= 31)
{
}
else
{
}
break;
case 2:
//Especial para mes de febrero
bisiesto = ao % 4;
if (dia == 29)
{
if (bisiesto == 0)
{
printf("\nLa fecha ingresada es valida.\n\n", ao);
}
else
{
}
51
}
else
{
if (dia > 0 && dia < 29)
{
}
case
case
case
case
}
break;
4:
6:
9:
11:
if (dia > 0 && dia <= 30)
{
}
else
{
}
break;
}
}
void main()
{
int dia = 0, mes = 0, ao = 0, bisiesto = 0;
printf("Ingrese un numero de dia: ");
scanf("%d", &dia);
printf("Ingrese un numero de mes: ");
scanf("%d", &mes);
printf("Ingrese un numero de a\xA4o: ");
scanf("%d", &ao);
if (ao > 0 && (mes > 0 && mes <= 12))
{
func_ComprFecha(dia, mes, ao, bisiesto);
}
else
{
}
system("Pause");
}
52
//Ejercicio 12
#include <stdio.h>
#include <stdlib.h>
int func_MayorImp(float importe, int mayorImp, int nroProd)
{
if (importe > mayorImp)
{
mayorImp = nroProd;
}
return mayorImp;
}
int func_MasVend(int cant, int masVend, int nroProd)
{
if (cant > masVend)
{
masVend = nroProd;
}
return masVend;
}
void main()
{
int nroFact = 0, nroProd = 0, cant = 0, masVend = 0, mayorImp = 0, i = 0;
int masVendido = 0, mayorImporte = 0;
float precio = 0.0, importe = 0.0;
while (nroProd != 999)
{
printf("Ingrese el numero de producto: ");
scanf("%d", &nroProd);
if (nroProd != 999)
{
printf("Ingrese numero de factura: ");
scanf("%d", &nroFact);
printf("Ingrese cantidad de productos: ");
scanf("%d", &cant);
masVendido = func_MasVend(cant, masVend, nroProd);
printf("Ingrese precio unitario de producto: ");
scanf("%f", &precio);
importe = precio * cant;
mayorImporte = func_MayorImp(importe, mayorImp, nroProd);
printf("\n");
}
else
{
printf("\nEl producto mas vendido es el: %d\n", masVendido);
printf("El producto de mayor importe vendido es el: %d\n\n",
mayorImporte);
break;
}
}
system("Pause");
}
53
//Ejercicio 13
#include <stdio.h>
#include <stdlib.h>
float func_promAlum(float promParcial, float promGeneral, int notaAct, int notaTP,
int numACT)
{
promGeneral = (promParcial + notaTP) / (numACT);
printf("\nPromedio de alumno: %.2f\n\n---------------------------------------\n", promGeneral);
return promGeneral;
}
int func_mayorProm(float promGeneral, int mayorProm, int mejorProm, int i)
{
if (promGeneral > mayorProm)
{
mayorProm = promGeneral;
mejorProm = i;
}
return mejorProm;
}
void main()
{
int alumno = 0, i = 1, mayorProm = 0, TPaprob = 0, alumINSUF = 0, numACT = 1,
mejorProm = 0;
int mejorPromedio = 0.0;
float promParcial = 0.0, promGeneral = 0.0, promCurso = 0.0, notaTP = 0.0,
notaAct = 0.0;
float promAlumno = 0.0;
for (i = 1; i <= 3; i++)
{
printf("Numero de alumno: %d\n\n", i);
printf("Actividad: TP - Ingrese nota de Trabajo Practico: ");
scanf("%f", &notaTP);
if (notaTP < 0 || notaTP > 10)
{
printf("\nINGRESO VALOR INCORRECTO (Solo numeros de 0 a 10) \n\aPor
favor, intente nuevamente:\n\n");
notaTP = 0;
i--;
}
else
{
printf("\nIngrese numero NEGATIVO para finalizar ingreso.\n");
while (notaAct >= 0 && notaAct <= 10)
{
printf("Actividad: %d - Ingrese nota de actividad: ",
numACT);
scanf("%f", &notaAct);
numACT++;
promParcial = promParcial + notaAct;
if (notaAct > 10)
{
10) \n\aPor favor, intente nuevamente:\n\n");
54
numACT--;
notaAct = 0;
}
}
numACT--;
if (numACT <= 3)
{
alumINSUF++;
}
promAlumno = func_promAlum(promParcial, promGeneral, notaAct,
notaTP, numACT);
mejorPromedio = func_mayorProm(promGeneral, mayorProm,
mejorProm, i);
if (notaTP >= 6)
{
TPaprob++;
}
notaAct = 0;
notaTP = 0;
numACT = 1;
promParcial = 0;
promCurso = promCurso + promAlumno;
promGeneral = 0;
numACT = 1;
notaAct = 0;
}
printf("\n");
}
printf("Numero de alumno con mejor promedio: %d\n", mejorPromedio);
printf("Promedio total del curso: %.2f \n", promCurso);
printf("Alumnos con 2 o menos actividades registradas: %d \n", alumINSUF);
printf("Alumnos con TP aprob: %d \n\n", TPaprob);
system("Pause");
}
-------------------------------------------------//Ejercicio 14
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void func_sexo(int *male, int *female);
int func_naci(int anioAct);
void func_estadisticas(int cantIngre, int cantMenor, int male, int female, int
infeTreinta);
void main()
{
long int dni = 0;
int nacim = 0, anioAct = 0;
int male = 0, female = 0, infeTreinta = 0, cantMenor = 0, cantIngre = 0;
printf("Ingrese anio actual: ");
55
scanf("%d", &anioAct);
while (getchar() != '\n');
while (dni >= 0)
{
system("cls");
printf("Ingrese numero de DNI: ");
scanf("%ld", &dni);
if (dni >= 0)
{
if (dni < 30000000)
{
infeTreinta++;
}
func_sexo(&male, &female);
cantMenor = func_naci(anioAct);
}
else
{
break;
}
cantIngre++;
}
func_estadisticas(cantIngre, cantMenor, male, female, infeTreinta);
}
void func_sexo(int *male, int *female)
{
int contSex = 0;
char sexo;
for (contSex = 1; contSex <= 1; contSex++)
{
printf("Ingrese sexo <M o F> segun corresponda: ");
sexo = getchar();
switch (sexo)
{
case 'm':
case 'M':
*male = *male + 1;
break;
case 'f':
case 'F':
*female = *female + 1;
break;
default:
printf("\aERROR: Ingreso un caracter incorrecto. Intente
nuevamente...");
getch();
system("cls");
contSex--;
}
}
}
int func_naci(int anioAct)
{
int contNaci = 0, nacim = 0, cantMenor = 0;
for (contNaci = 1; contNaci <= 1; contNaci++)
56
{
printf("Ingrese anio de nacimiento: ");
scanf("%d", &nacim);
if (nacim < 0 || nacim > anioAct)
{
printf("\aERROR: Ingreso un caracter incorrecto. Intente
nuevamente...");
getch();
system("cls");
contNaci--;
}
else
{
if ((anioAct - nacim) < 18)
{
cantMenor++;
}
}
}
return cantMenor;
}
void func_estadisticas(int cantIngre, int cantMenor, int male, int female, int
infeTreinta)
{
float porcenMenor = 0;
if (cantIngre > 0)
{
porcenMenor = (cantMenor * 100) / cantIngre;
system("cls");
printf("Calculos realizados, pulse una tecla para continuar...");
getch();
system("cls");
printf("..::ESTADISTICAS::..\n\n");
printf("Cantidad de personas Masculinas: %d\n", male);
printf("Cantidad de personas Femeninas: %d\n", female);
printf("Cantidad de personas con DNI inferior a 30 millones: %d\n",
infeTreinta);
printf("Porcentaje de personas menores de edad: %%%.2f\n\n",
porcenMenor);
system("Pause");
}
else
{
system("cls");
printf("No se pueden realizar calculos si no hay personas
registradas...");
getch();
}
}
57
//Ejercicio 15
#include <stdio.h>
#include <stdlib.h>
int unsigned long func_factorial(int numero)
{
int i = 0;
int long unsigned fctrial = 1;
{
printf("%d x ", i);
fctrial = fctrial * i;
if (i == 2)
{
printf("1\n");
}
}
return fctrial;
}
int main()
{
int cont = 0, numero = 0;
int unsigned long factorial = 0;
{
printf("Ingrese un numero (ENTERO) para hallar sus factoriales: ");
if (numero >= 0)
{
if (numero == 0 || numero == 1)
{
printf("\nEl factorial de %d es: 1", numero);
}
if (numero >= 0)
{
factorial = func_factorial(numero);
printf("El factorial de %d es: %lu\n\n", numero,
factorial);
}
}
else
{
printf("\n<<Ingreso un valor no valido, solo numeros MAYORES o
IGUALES a 0>>\n\n");
cont--;
}
} //FOR
system("Pause");
}
58
//Ejercicio 16
#include <stdio.h>
#include <stdlib.h>
void func_tablas(int numero)
{
int i = 0, result = 0;
for (i = 0; i <= 10; i++)
{
result = numero * i;
printf("\n%d x %d = %d", numero, i, result);
}
}
main()
{
int numero = 0;
printf("Ingrese un numero para mostrar su tabla de multiplicar: ");
func_tablas(numero);
printf("\n\n");
system("Pause");
}
-------------------------------------------------- //Ejercicio 17
#include <stdio.h>
#include <stdlib.h>
int func_SumaInter(int limit2, int i)
{
int restoCero = 0, suma = 0;
restoCero = i % 5;
if (restoCero == 0)
{
suma = suma + i;
printf("%d", i);
if (i < limit2)
{
printf(" + ");
}
}
return suma;
}
void main()
{
int limit1 = 0, limit2 = 0, sumatoria = 0, i = 0, cont = 0, cumpleCond = 0;
printf("Ingrese el limite mas bajo <ENTERO>: ");
{
printf("Ingrese el limite mas alto <ENTERO>: ");
if (limit2 <= limit1)
59
{
printf("\nERROR: Ha ingresado un valor menor o igual al limite
mas bajo.");
cont--;
}
printf("\n");
for (i = limit1; i <= limit2; i++)
{
sumatoria = sumatoria + func_SumaInter(limit2, i);
}
if (sumatoria != 0)
{
printf("\n\nLa suma de los multiplos de 5 entre %d y %d es:
%d\n\n", limit1, limit2, sumatoria);
}
else
{
printf("\nNo hay numeros en el rango %d / %d que sean multiplos
de 5. SUMA = 0\n\n", limit1, limit2);
}
}
system("Pause");
}
-----------------------------------------------------------------------------------//Ejercicio 18
#include <stdio.h>
#include <stdlib.h>
int func_multiplicar(int num1, int num2, int i)
{
int result = 0;
result = result + num1;
printf("%d", num1);
if (i < num2)
{
printf(" + ");
}
return result;
}
void main()
{
int num1 = 0, num2 = 0, i = 0, resultado = 0, cont = 0;
{
printf("Ingrese un factor <ENTERO POSITIVO>: ");
scanf("%d", &num1);
if (num1 < 0)
{
cont--;
}
printf("Ingrese el segundo factor <ENTERO POSITIVO>: ");
scanf("%d", &num2);
if (num2 < 0)
60
{
cont--;
}
for (i = 1; i <= num2; i++)
{
resultado = resultado + func_multiplicar(num1, num2, i);
}
}
printf("\n\nEl producto de %d y %d sin usar la operacion <*> es: %d\n\n",
num1, num2, resultado);
system("Pause");
}
-----------------------------------------------------------------------------------//Ejercicio 19
#include <stdio.h>
#include <stdlib.h>
int division(int *num1, int *num2, int *result, int *cont);
void main()
{
int num1 = 0, num2 = 0, result = 0, cont = 0, valorTotal = 0;
{
scanf("%d", &num1);
if (num1 < 0)
{
cont--;
}
scanf("%d", &num2);
if (num2 < 0)
{
cont--;
}
valorTotal = division(&num1, &num2, &result, &cont);
}
system("Pause");
}
int division(int *num1, int *num2, int *result, int *cont)
{
int valorTotal = 0;
*result = *num1;
if (*num1 > *num2)
{
do
{
61
*result = *result - *num2;

valorTotal++;
} while (*result >= *num2);
}
else
{
*cont--;
}
return valorTotal;
}
-----------------------------------------------------------------------------------//Ejercicio 20
#include <stdio.h>
#include <stdlib.h>
int division(int *num1, int *num2, int *result, int *cont);
void main()
{
int num1 = 0, num2 = 0, result = 0, cont = 0, valorTotal = 0;
{
scanf("%d", &num1);
if (num1 < 0)
{
cont--;
}
scanf("%d", &num2);
if (num2 < 0)
{
cont--;
}
valorTotal = division(&num1, &num2, &result, &cont);
}
system("Pause");
}
int division(int *num1, int *num2, int *result, int *cont)
{
int valorTotal = 0;
*result = *num1;
if (*num1 > *num2)
{
do
{
*result = *result - *num2;
62
valorTotal++;
} while (*result >= *num2);
}
else
{
*cont--;
}
return valorTotal;
}
-----------------------------------------------------------------------------------//Ejercicio 21
#include <stdio.h>
#include <stdlib.h>
void bisiesto(int anio, int *cont);
void main()
{
int anio = 0, cont = 0, resto = 0;
printf("<<ADVERTENCIA: Si ingresa un numero negativo sera usado como anios
a.C.>>\n\n");
{
printf("Ingrese un anio distinto de 0: ");
scanf("%d", &anio);
bisiesto(anio, &cont);
}
system("Pause");
}
void bisiesto(int anio, int *cont)
{
int resto = 0;
if (anio < 0)
{
anio = anio*(-1);
}
if (anio == 0)
{
printf("\n<<ERROR: Le dije que ingresara un valor distinto de 0 :@
>>\n\n");
*cont = *cont - 1;
system("Pause");
system("cls");
}
if (anio > 0)
{
resto = anio % 4;
if (resto == 0)
{
resto = 0;
resto = anio % 100;
if (resto == 0)
63
{
resto = 0;
resto = anio % 400;
if (resto == 0)
{
}
else
{
}
}
else
{
}
}
else
{
}
}
}
-----------------------------------------------------------------------------------//Ejercicio 22
#include <stdio.h>
#include <stdlib.h>
int func_capicua(int num, int inicial);
void main()
{
int num = 0, inicial = 0, capicua = 0;
printf("Ingrese un numero de 4 cifras: ");
scanf("%d", &num);
inicial = num;
capicua = func_capicua(num, inicial);
if (capicua == inicial)
{
printf("El numero SI es capicua\n");
}
else
{
printf("El numero NO es capicua\n");
}
system("Pause");
}
int func_capicua(int num, int inicial)
{
int uniMil = 0, cent = 0, dece = 0, uni = 0, capicua = 0;
64
cent = num / 100;

dece = num / 10;
num = num - (10 * dece);
uni = inicial - (1000 * uniMil) - (cent * 100) - (dece * 10);
capicua = uniMil + (1000 * uni) + (dece * 100) + (cent * 10);
return capicua;
}
-----------------------------------------------------------------------------------//Ejercicio 23 Practicando con punteros
#include <stdio.h>
#include <stdlib.h>
void desgloce(long int num, int *uni, int *dec, int *cent, int *uniMil, int *decMil,
int *centMil);
void main()
{
int uni = 0, dec = 0, cent = 0, uniMil = 0, decMil = 0, centMil = 0, i = 0;
long int num = 0, copia = 0;
printf("Ingrese un numero de 6 cifras <<dd-mm-aa>>: ");
scanf("%d", &num);
desgloce(num, &uni, &dec, &cent, &uniMil, &decMil, &centMil);
printf("\nDia: %d%d", centMil, decMil);
printf("\nMes: %d%d", uniMil, cent);
printf("\nA\xA4o: %d%d\n\n", dec, uni);
system("Pause");
}
void desgloce(long int num, int *uni, int *dec, int *cent, int *uniMil, int *decMil,
int *centMil)
{
long int copia;
copia = num;
if (num >= 100000)
{
*centMil = num / 100000;
num = num - (100000 * *centMil);
}
*decMil = num / 10000;
num = num - (10000 * *decMil);
*uniMil = num / 1000;
num = num - (1000 * *uniMil);
*cent = num / 100;
num = num - (100 * *cent);
*dec = num / 10;
num = num - (10 * *dec);
*uni = copia - (100000 * *centMil) - (10000 * *decMil) - (1000 * *uniMil) (*cent * 100) - (*dec * 10);
}
65
//Ejercicio 24
#include <stdio.h>
#include <stdlib.h>
int func_perfecto(int num);
void main()
{
int num = 0, suma = 0;
printf("Ingrese un numero para su verificacion: ");
scanf("%d", &num);
suma = func_perfecto(num);
if (suma == num)
{
printf("\nEl numero ingresado SI es perfecto.\n\n");
}
else
{
printf("\nEl numero ingresado NO es perfecto.\n\n");
}
system("Pause");
}
int func_perfecto(int num)
{
int i = 0, division = 0, suma = 0;
for (i = num - 1; i >= 1; i--)
{
division = num % i;
if (division == 0)
{
suma = suma + i;
}
}
return suma;
}
-----------------------------------------------------------------------------------//Ejercicio 25
#include <stdio.h>
#include <stdlib.h>
void func_facto(int P, int Q, int *cont);
void main()
{
int P = 0, Q = 0, cont = 0;
{
scanf("%d", &P);
scanf("%d", &Q);
if (P >= 0)
66
{
func_facto(P, Q, &cont);
}
else
{
nuevamente:\n\n");
cont--;
}
}
system("Pause");
}
void func_facto(int P, int Q, int *cont)
{
int i = 0, PmenosQ = 0;
long float result = 0;
int long unsigned factorialA = 1, factorialB = 1;
for (i = P; i >= 1; i--)
{
}
if (P == 0)
{
factorialA = 1;
}
i = 0;
PmenosQ = P - Q;
if (PmenosQ >= 0)
{
for (i = PmenosQ; i >= 1; i--)
{
factorialB = factorialB * i;
}
}
else
{
printf("\nERROR: No se pudo calcular el factorial de P - Q , la resta
da un numero negativo, intente nuevamente:\n\n");
*cont = *cont - 1;
}
}
-----------------------------------------------------------------------------------//Ejercicio 26
#include <stdio.h>
#include <stdlib.h>
void func_fibo(int limite);
void main()
{
int limite = 0, cont = 0;
67

{
if (limite > 0)
{
func_fibo(limite);
}
else
{
cont--;
}
}
printf("\n\n");
system("Pause");
}
void func_fibo(int limite)
{
int varA = 0, varB = 1, i = 0, secue = 1;
{
if (i < limite)
{
printf(", ");
}
varB = varA;
varA = secue;
}
}
-----------------------------------------------------------------------------------// Ejercicio 27
#include <stdio.h>
#include <stdlib.h>
void func_dibuja(int num);
void main()
{
int num = 0;
scanf("%d", &num);
printf("\n");
func_dibuja(num);
printf("\n");
system("Pause");
}
68
void func_dibuja(int num)

{
int i = 0, j = 0, k = 0;
for (i = 0; i <= num; i++)
{
for (k = num - 1; k >= i; k--)
{
printf(" ");
}
for (j = 0; j <= i * 2; j++)
{
printf("*");
}
printf("\n");
}
}
-----------------------------------------------------------------------------------//Ejercicio 28 mostrar signos del zodiaco. Sin sentido usar funciones
-----------------------------------------------------------------------------------//Ejercicio 29
#include <stdio.h>
#include <stdlib.h>
void func_vuelto(float importe, float efectivo, int *i);
void main()
{
float importe = 0.0, efectivo = 0.0;
int i = 0;
printf("BIENVENIDO AL SUPERCHINO...\n\n");
for (i = 1; i <= 1; i++)
{
printf("Ingrese el monto a pagar: ");
scanf("%f", &importe);
printf("Ingrese el monto recibido del cliente: ");
scanf("%f", &efectivo);
func_vuelto(importe, efectivo, &i);
}
system("Pause");
}
void func_vuelto(float importe, float efectivo, int *i)
{
float vuelto = 0;
if (efectivo >= importe)
{
vuelto = efectivo - importe;
printf("\nEl vuelto es: %.2f pesos.\n\n", vuelto);
}
else
{
printf("\nERROR: Ha ingresado un monto recibido del cliente menor al
importe o...\n");
69
printf("ADVERTENCIA: Lo quieren estafar... Ingrese nuevamente ambos

valores:\n\n");
*i = *i - 1;
}
}
-----------------------------------------------------------------------------------//Ejercicio 30
#include <stdio.h>
#include <stdlib.h>
int func_orden(int num1, int num2, int canti, int *i, int primerNum, int *ascCont,
int *desCont)
{
int desorden = 0, ultNum = 0, suma = 0;
if (num2 > num1)
{
*ascCont = *ascCont + 1;
num1 = num2;
}
if (num2 < num1)
{
*desCont = *desCont + 1;
num1 = num2;
}
else
{
desorden++;
}
if (*i == canti - 1)
{
ultNum = num2;
suma = primerNum + ultNum;
}
return suma;
}
void main()
{
int num1 = 0, num2 = 0, canti = 0, i = 1, suma = 0, ascCont = 1, desCont = 1,
primerNum;
printf("Ingrese la cantidad de numero a ingresar: ");
scanf("%d", &canti);
scanf("%d", &num1);
primerNum = num1;
for (i = 1; i <= canti - 1; i++)
{
scanf("%d", &num2);
suma = func_orden(num1, num2, canti, &i, primerNum, &ascCont,
&desCont);
}
70
if (ascCont == i)
{
printf("\nORDEN: ASCENDENTE\n\n");
}
else
{
if (desCont == i)
{
printf("\nORDEN: DESCENDENTE\n\n");
}
else
{
printf("\nORDEN: DESORDENADOS\n\n");
}
}
printf("La suma entre el primer y ultimo numero ingresado es: %d\n\n", suma);
system("Pause");
}
-----------------------------------------------------------------------------------//Ejercicio 31
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void fibonacci(int *contPpal);
void factorial(int *contPpal);
void main()
{
//Ejercicio realizado antes de ver ciclo de repeticion Do-While
int opcion = 0, contPpal = 0;
for (contPpal = 1; contPpal <= 1; contPpal++)
{
system("cls");
printf("MENU:\n\n");
printf("1: Salir\n2: Mostrar secuencia de Fibonacci\n3: Calculadora de
Factoriales\n\nIngrese una opcion: ");
switch (opcion)
{
case 1:
break;
case 2:
fibonacci(&contPpal);
break;
case 3:
factorial(&contPpal);
break;
default:
contPpal--;
printf("\aERROR: Ha ingresado un valor incorrecto, intente
nuevamente: \n\n");
printf("--------------------------------\n\n");
getch();
71
}
}
}
void fibonacci(int *contPpal)
{
int varA = 0, varB = 1, i = 0, limite = 0, contFibo = 0, secue = 1,
cuentaComa = 0;
system("cls");
printf("--------------------------------");
printf("\nSECUENCIA DE FIBONACCI:\n\n");
for (contFibo = 1; contFibo <= 1; contFibo++)
{
if (limite > 0)
{
{
if (i < limite)
{
printf(", ");
}
varB = varA;
varA = secue;
}
}
else
{
contFibo--;
}
}
printf("\n\n");
printf("--------------------------------\n\n");
getch();
*contPpal = *contPpal - 1;
}
void factorial(int *contPpal)
{
int numero = 0, iFact = 0, contFact = 0;
system("cls");
printf("--------------------------------");
printf("\nCALCULADORA DE FACTORIAL:\n\n");
for (contFact = 1; contFact <= 1; contFact++)
{
if (numero > 0)
{
for (iFact = numero; iFact >= 2; iFact--)
{
72
printf("%d x ", iFact);

factorial = factorial * iFact;
if (iFact == 2)
{
printf("1");
}
}
}
else
if (numero == 0)
{
printf("1");
factorial = 1;
}
else
{
contFact--;
}
printf("\n\n");
}
*contPpal = *contPpal - 1;
printf("--------------------------------\n\n");
getch();
}
//Ejercicio 32
#include <stdio.h>
#include <stdlib.h>
int ingreso(int *cantPers, int *prod1, int *prod2, int *prodAmbos);
int porcen(int cantPers, int prod1, int prod2, int prodAmbos, float *porcen1, float
*porcen2, float *porcen3);
void main()
{
float porcen1 = 0, porcen2 = 0, porcen3 = 0;
int opcion = 0;
int cantPers = 0;
int prod1 = 0, prod2 = 0, prodAmbos = 0;
printf("Opciones:\n\n");
printf("Otro: Ambos productos\n\n");
printf("Numero negativo: Para finalizar ingreso. \n\n");
while (opcion >= 0)
{
opcion = ingreso(&cantPers, &prod1, &prod2, &prodAmbos);
}
if (cantPers != 0)
{
cantPers = porcen(cantPers, prod1, prod2, prodAmbos, &porcen1,
&porcen2, &porcen3);
73
}
system("cls");
printf("Cantidad de personas entrevistadas: %d\n\n", cantPers);
printf("Porcentaje de personas que eligio el producto 1: %.2f\n", porcen1);
printf("Porcentaje de personas que eligio el producto 2: %.2f\n\n", porcen2);
printf("Porcentaje de personas que eligio ambos productos: %.2f\n\n",
porcen3);
system("Pause");
}
int ingreso(int *cantPers, int *prod1, int *prod2, int *prodAmbos)
{
int opcion = 0;
*cantPers = *cantPers + 1;
printf("Opcion: ");
switch (opcion)
{
case 1:
*prod1 = *prod1 + 1;
break;
case 0:
*prod2 = *prod2 + 1;
break;
}
if (opcion > 0 && opcion != 1 && opcion != 0)
{
*prodAmbos = *prodAmbos + 1;
}
return opcion;
}
int porcen(int cantPers, int prod1, int prod2, int prodAmbos, float *porcen1, float
*porcen2, float *porcen3)
{
cantPers--;
*porcen1 = (prod1 * 100) / cantPers;
*porcen2 = (prod2 * 100) / cantPers;
*porcen3 = (prodAmbos * 100) / cantPers;
return cantPers;
}
74
Tercera Gua Parte Dos (Solo Funciones) Estructuras de Control

//Ejercicio 33
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
float volumen(float a, float b, float c)
{
float vol = 0;
vol = a * b * c;
return vol;
}
float capacidad(float a)
{
float capaci = 0;
capaci = a * 7.8;
return capaci;
}
void horas(float a)
{
int time = 0;
time = (a / 20) / 60;
printf("\nLa cantidad de horas requeridas para llenar la piscina es de %d
aprox.", time);
}
void main()
{
float vol = 0, capaci = 0, longi = 0, ancho = 0, profun = 0;
printf("Ingrese la longitud de la piscina <pies>: ");
scanf("%f", &longi);
printf("Ingrese el ancho de la piscina <pies>: ");
scanf("%f", &ancho);
printf("Ingrese la profundidad de la piscina <pies>: ");
scanf("%f", &profun);
vol = volumen(longi, ancho, profun);
capaci = capacidad(vol);
horas(capaci);
getch();
}
75
//Ejercicio 34
#include <stdio.h>
#include <stdlib.h>
void func_vali();
void main()
{
func_vali();
}
void func_vali()
{
char var;
printf("Ingrese un valor <simbolo para salir>: ");
scanf("%c", &var);
if (var >= 48 && var <= 57)
{
printf("\n3\n\n");
func_vali();
}
if (var >= 97 && var <= 122)
{
printf("\n2\n\n");
func_vali();
}
if (var >= 65 && var <= 90)
{
printf("\n1\n\n");
func_vali();
}
}
----------------------------------------------------------------------------------//Ejercicio 35
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void func_time(int hs, int min, int seg, int *horas, int *minutos, int *segundos)
{
if (seg >= 60)
{
*segundos = seg % 60;
min = min + (seg / 60);
*minutos = min;
}
if (min >= 60)
{
*minutos = min % 60;
hs = hs + (min / 60);
}
*horas = hs;
}
76
void func_comp(int h1, int m1, int s1, int h2, int m2, int s2)
{
if (h1 > h2)
{
printf("\nEl primer instante NO es anterior al segundo...\n");
printf("Instante 1: %d hs - %d min - %d segs\n", h1, m1, s1);
}
else
{
if (h1 < h2)
{
printf("\nEl primer instante SI es anterior al segundo...\n");
}
else
{
if (m1 > m2)
{
printf("\nEl primer instante NO es anterior al
segundo...\n");
printf("Instante 1: %d hs - %d min - %d segs\n", h1, m1,
s1);
printf("Instante 2: %d hs - %d min - %d segs\n", h2, m2,
s2);
}
else
{
if (m1 < m2)
{
printf("\nEl primer instante SI es anterior al
segundo...\n");
printf("Instante 1: %d hs - %d min - %d segs\n",
h1, m1, s1);
printf("Instante 2: %d hs - %d min - %d segs\n",
h2, m2, s2);
}
else
{
if (s1 > s2)
{
printf("\nEl primer instante NO es anterior
al segundo...\n");
printf("Instante 1: %d hs - %d min - %d q
segs\n", h1, m1, s1);
printf("Instante 2: %d hs - %d min - %d
segs\n", h2, m2, s2);
}
else
{
if (s1 < s2)
{
printf("\nEl primer instante SI es
anterior al segundo...\n");
printf("Instante 1: %d hs - %d min %d segs\n", h1, m1, s1);
77

}
else
{
printf("\nAmbos instantes ocurren al
mismo tiempo...\n");
}
}
}
}
}
}
}
void main()
{
int time[4], time2[4];
int horas1, minutos1, segundos1;
int horas2, minutos2, segundos2;
printf("Indique la hora del primer instante: ");
scanf("%d", &time[1]);
printf("Indique los minutos del primer instante: ");
printf("Indique los segundos del primer instante: ");
func_time(time[1], time[2], time[3], &horas1, &minutos1, &segundos1);
printf("\n");
printf("Indique la hora del segundo instante: ");
scanf("%d", &time2[1]);
printf("Indique los minutos del segundo instante: ");
printf("Indique los segundos del segundo instante: ");
func_time(time2[1], time2[2], time2[3], &horas2, &minutos2, &segundos2);
func_comp(horas1, minutos1, segundos1, horas2, minutos2, segundos2);
getch();
}
-----------------------------------------------------------------------------------//Ejercicio 36
#include
#include
#include
#include
<stdio.h>
<stdlib.h>
<conio.h>
<time.h>
float func_apuesta(int *cont, float saldoBanca, float apuestaAct, float

saldoJugador, int booleana)
{
system("cls");
printf("Saldo de la BANCA: %.2f\n", saldoBanca);
if (saldoBanca > 0)
78
{
printf("Ingrese el valor de apuesta: ");
scanf("%f", &apuestaAct);
while (getchar() != '\n'); //Vacia buffer
if (apuestaAct <= 0 || apuestaAct > 2000)
{
printf("\n\aIngreso un valor no correspondido, procure leer las
instrucciones\nsi no entendio que hay que hacer...");
*cont = *cont - 1;
getch();
}
}
else
{
printf("La banca se ha quedado sin fondos");
booleana = 0;
}
return apuestaAct;
}
int func_tirarDados(int *dado1, int *dado2, int sumaDados, float saldoBanca, float
saldoJugador, float apuestaAct, int primerTiro)
{
system("cls");
printf("Saldo de banca: %.2f\n", saldoBanca);
printf("Saldo jugador: %.2f\n", saldoJugador);
printf("Apuesta en curso: %.2f\n", apuestaAct);
printf("En tu primer tiro sacaste: %d\n\n", primerTiro);
printf("Pulse una tecla para tirar los dados...");
getch();
system("cls");
*dado1 = 1 + rand() % 6;
*dado2 = 1 + rand() % 6;
sumaDados = *dado1 + *dado2;
printf("DADO 1: %d\nDADO 2: %d\n\nLa suma de ambos dados es de: %d", *dado1,
*dado2, sumaDados);
getch();
return sumaDados;
}
int func_primerTiro(int *sumaDados, int *booleana, float saldoJugador, float
apuestaAct, float saldoBanca)
{
int sumaPrimer = 0;
sumaPrimer = *sumaDados;
*sumaDados = 0;
switch (sumaPrimer)
{
case 7:
case 11:
system("cls");
printf("FELICIDADES, HA GANADO EN EL PRIMERO TIRO!!\n\n");
saldoJugador = saldoJugador + apuestaAct;
saldoBanca = saldoBanca - apuestaAct;
printf("Punto para el jugador!!\n\n");
getch();
*booleana = 0;
break;
79
case 2:
case 3:
case 12:
system("cls");
printf("OPS!, HA PERDIDO, NO PODIA SUMAR %d EN EL PRIMER TIRO. BANCA
GANA.\n\n", sumaPrimer);
saldoJugador = saldoJugador - apuestaAct;
saldoBanca = saldoBanca + apuestaAct;
printf("Acaba de perder: %.2f\n\n", apuestaAct);
getch();
*booleana = 0;
break;
default:
*booleana = 1;
}
return sumaPrimer;
}
void main()
{
srand(time(NULL));
int dado1 = 0, dado2 = 0, sumaDados = 0, numTiro = 0, sumaPrimer = 0, cont =
0, opcion = 0, seguir = 0;
int booleana = 1;
float saldoBanca = 2000, saldoJugador = 0, apuestaAct = 0;
do
{
printf("..::JUEGO DE DADOS::..\n\n");
printf("Menu:\n\n");
printf("1. Jugar\n");
printf("2. Instrucciones\n");
printf("3. Salir\n\n");
printf("Opcion: ");
switch (opcion)
{
case 1:
{
apuestaAct = func_apuesta(&cont, saldoBanca, apuestaAct,
saldoJugador, booleana);
}
do
{
sumaDados = func_tirarDados(&dado1, &dado2, sumaDados,
saldoBanca, saldoJugador, apuestaAct, sumaPrimer);
numTiro++;
if (numTiro == 1)
{
sumaPrimer = func_primerTiro(&sumaDados,
&booleana, saldoJugador, apuestaAct, saldoBanca);
}
} while (sumaDados != sumaPrimer && sumaDados != 7 && booleana
== 1);
80
if (booleana == 1)
{
if (sumaDados == sumaPrimer)
{
system("cls");
saldoJugador = saldoJugador + apuestaAct;
saldoBanca = saldoBanca - apuestaAct;
printf("Punto para el jugador!!\n\n");
printf("Apuesta en curso: %.2f\n\n", apuestaAct);
{
apuestaAct = func_apuesta(&cont,
saldoBanca, apuestaAct, saldoJugador,
booleana); //Se apuesta hasta ingresar
valor correcto
}
booleana = 0;
getch();
}
else
{
system("cls");
saldoJugador = saldoJugador - apuestaAct;
saldoBanca = saldoBanca + apuestaAct;
printf("Acaba de perder: %.2f\n\n", apuestaAct);
printf("\nPerdio, saco %d", sumaDados);
booleana = 0;
getch();
}
}
if (booleana == 0)
{
system("cls");
printf("FIN DEL JUEGO");
}
break;
case 2:
system("cls");
printf("..::INSTRUCCIONES::..\n\n");
printf("Este es un juego de dados clasico, donde un jugador
juega y apuesta contra la banca. Un jugador tira dos dados, Si
la suma de estos es 7 u 11 en el primer tiro,el jugador
gana.\n");
printf("Si la suma es 2, 3 o 12 en el primer tiro, el jugador
pierde ; es decir, la
banca gana. Si la suma es 4, 5, 6, 8,
9 o 10 en el primer tiro, esta suma se convierte en punto del
jugador.\n");
printf("Para ganar, el jugador debe seguir tirando los dados
hasta que salga otra vez su punto <es decir, que tire ese mismo
valor de punto>.\n");
printf("El jugador pierde si tira un 7 antes de llegar a su
punto.\n");
getch();
81
system("cls");
break;
}
} while (opcion != 3);
}
----------------------------------------------------------------------------------//Ejercicio 38
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void ingreso(int *anio1, int *anio2);
int func_anios(int anio1, int anio2, int *mayor, int *menor);
int bisiesto(int mayor, int menor, int dias, int *cantBisi);
void main()
{
int dias = 0, horas = 0;
unsigned long int minutos = 0, segundos = 0;
int mayor = 0, menor = 0;
int anio1 = 0, anio2 = 0, cantAnios = 0, cantBisi = 0, opcion = 0;
ingreso(&anio1, &anio2);
do
{
system("cls");
cantAnios = func_anios(anio1, anio2, &mayor, &menor);
system("cls");
dias = cantAnios * 365;
dias = bisiesto(mayor, menor, dias, &cantBisi);
horas = dias * 24;
minutos = horas * 60;
segundos = minutos * 60;
printf("...::MENU::...\n\n");
printf("Cantidad de a%cos: %d\n", 164, cantAnios);
printf("Cantidad de a%cos bisiestos: %d\n\n", 164, cantBisi);
printf("1. Convertir a dias\n");
printf("2. Convertir a horas\n");
printf("3. Convertir a minutos\n");
printf("4. Convertir a segundos\n");
printf("5. Realizar otro ingreso\n");
printf("Opcion: ");
switch (opcion)
{
case 1:
system("cls");
printf("Cantidad de a%cos expresados en dias: %d\n\n", 164,
cantAnios);
printf("Dias: %d\n\n", dias);
system("Pause");;
break;
82
case 2:
system("cls");
printf("Cantidad de a%cos expresados en horas: %d\n\n", 164,
cantAnios);
printf("Horas: %d\n\n", horas);
system("Pause");
break;
case 3:
system("cls");
printf("Cantidad de a%cos expresados en minutos: %d\n\n", 164,
cantAnios);
printf("Minutos: %lu\n\n", minutos);
system("Pause");
break;
case 4:
system("cls");
printf("Cantidad de a%cos expresados en segundos: %d\n\n", 164,
cantAnios);
printf("Segundos: %lu\n\n", segundos);
system("Pause");
break;
case 5:
system("cls");
anio1 = 0;
anio2 = 0;
cantBisi = 0;
ingreso(&anio1, &anio2);
break;
}
}
void ingreso(int *anio1, int *anio2)
{
printf("Ingrese un a%co: ", 164);
scanf("%d", &*anio1);
printf("Ingrese otro a%co: ", 164);
scanf("%d", &*anio2);
}
int func_anios(int anio1, int anio2, int *mayor, int *menor)
{
int Anios = 0;
if (anio1 > anio2)
{
Anios = (anio1 - anio2);
*mayor = anio1;
*menor = anio2;
}
else
if (anio2 > anio1)
{
Anios = (anio2 - anio1);
*mayor = anio2;
*menor = anio1;
}
return Anios;
}
83
int bisiesto(int mayor, int menor, int dias, int *cantBisi)

{
int i = 0, resto = 0;
for (i = menor; i <= mayor; i++)
{
resto = i % 4;
if (resto == 0)
{
resto = 0;
resto = i % 100;
if (resto == 0)
{
resto = 0;
resto = i % 400;
if (resto == 0)
{
dias++;
*cantBisi = *cantBisi + 1;
}
}
else
{
dias++;
*cantBisi = *cantBisi + 1;
}
}
}
return dias;
}
-----------------------------------------------------------------------------------//Ejercicio 39
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int func_menu();
float func_cambio(float tarifa);
float func_vuelto(float tarifa, float abonado);
void main()
{
int opcion = 0;
float tarifa = 0, abonado = 0, vuelto = 0;
do
{
opcion = func_menu();
system("cls");
switch (opcion)
{
case 1:
tarifa = 1.10;
break;
case 2:
tarifa = 1.20;
break;
84
case 3:
tarifa = 1.75;
break;
}
if (opcion != 4)
{
abonado = func_cambio(tarifa);
vuelto = func_vuelto(tarifa, abonado);
system("cls");
printf("El vuelto correspondiente es de: $%.2f\n\n", vuelto);
getch();
}
}
int func_menu()
{
int opcion = 0;
system("cls");
printf("..::CALCULADORA DE VUELTO::..\n\n");
printf("Seleccione su viaje:\n\n");
printf("1. Viaje corto: $1.10\n");
printf("2. Viaje medio: $1.20\n");
printf("3. Viaje largo: $1.75\n");
printf("Opcion: ");
return opcion;
}
float func_cambio(float tarifa)
{
float monedas[6] = { 2, 1, 0.5, 0.25, 0.1, 0.05 };
int cantMonedas[6] = { 0, 0, 0, 0, 0, 0 };
float cambio = 0, pago = 0, i = 0;
int booleana = 0, f = 0;
printf("..::INGRESO DE CAMBIO A ABONAR::..\n\n");
for (i = 0; i < tarifa; i = i + pago)
{
pago = 0;
system("cls");
printf("A abonar: %.2f\n", tarifa);
printf("Abonado: %.2f\n\n", cambio);
printf("Monedas aceptadas: $2 - $1 - $0.50 - $0.25 - $0.10 $0.05\n\n");
printf("Ingrese moneda a abonar: ");
scanf("%f", &pago);
for (f = 0; f <= 6; f++)
{
if (pago == monedas[f])
{
cambio = cambio + pago;
booleana = 1;
cantMonedas[f] = cantMonedas[f] + 1;
break;
}
else
{
booleana = 0;
85
}
}
if (booleana == 0) //En caso de que no se halle esa moneda
{
printf("Ingreso una moneda incorrecta...");
i = i - pago;
getch();
}
}
system("cls");
printf("A abonar: %.2f\n", tarifa);
printf("Abonado: %.2f\n\n", cambio);
printf("Cambio ingresado:\n\n");
printf("Monedas de $2.00: %d\n", cantMonedas[0]);
printf("Monedas de $0.05: %d\n\n", cantMonedas[5]);
system("Pause");
return cambio;
}
float func_vuelto(float tarifa, float abonado)
{
float monedas[6] = { 2, 1, 0.5, 0.25, 0.1, 0.05 };
int cantMonedas[6] = { 0, 0, 0, 0, 0, 0 };
int j = 0;
float vuelto = 0, restaMoneda = 0;
vuelto = abonado - tarifa;
return vuelto;
}
---------------------------------------------------------------------------------//Ejercicio 40
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
char equi(float notaNum);
void recomendacion(char notaFinal);
void main()
{
float notaNum = 0;
char notaFinal;
printf("Tabla de equivalencias:\n\n");
printf("
10 = A+\n9 a 9.99 = A \n8 a 8.99 = B \n7 a 7.99 = C \n6 a
6.66 = D \n1 a 5.99 = F\n");
printf("____________________________\n\n");
printf("Ingrese la nota del alumno: ");
scanf("%f", &notaNum);
notaFinal = equi(notaNum);
if (notaNum == 10)
{
printf("\nLa nota del alumno en el sistem SGY es: %c+\n\n", notaFinal);
}
86
else
{
printf("\nLa nota del alumno en el sistem SGY es: %c\n\n", notaFinal);
}
printf("Pulse una tecla para ver una observacion...");
getch();
system("cls");
recomendacion(notaFinal);
printf("\n\n");
system("Pause");
}
void recomendacion(char notaFinal)
{
if (notaFinal == 'A')
{
printf("Excelente desempe%co, esperamos que siga asi y demuestre que
con esfuerzo,\nvoluntad y responsabilidad se pueden lograr nuestras
metas. Nuevamente, \nfelicitaciones!!", 164);
}
if (notaFinal == 'B')
{
printf("Nos alegra saber que hay alumnos que se esfuerzan por mejorar
cada dia. \nSiga asi y pronto llegara a obtener la mejor calificacion
posible. \nFelicitaciones!!");
}
if (notaFinal == 'C')
{
printf("Buena calificacion, esperamos que siga mejorando aun mas para
obtener \nmejores calificaciones. Gran trabajo!!");
}
if (notaFinal == 'D')
{
printf("Aprobado con lo justo pero aprobado. Vamos, no se conforme con
una nota regular,esfuercese mas y mas para conseguir las mejores
calificaciones. \nCon dedicacion y esfuerzo todo es posible.
Adelante!!");
}
if (notaFinal == 'F')
{
printf("Ups!, no se dio esta vez... Vamos, no se rinda y siga
intentando, todos tenemos malos dias. El dia del examen no fue el suyo.
Dedique mayor esfuerzo y voluntad al estudio de esta materia que se le
ha complicado, vera que con ganas es todo \nmas facil. Adelante!!");
}
}
char equi(float notaNum)
{
char sgy;
if (notaNum == 10)
{
sgy = 'A';
}
if (notaNum >= 9 && notaNum <= 9.99)
{
sgy = 'A';
}
87
if (notaNum >= 8 &&

{
sgy = 'B';
}
if (notaNum >= 7 &&
{
sgy = 'C';
}
if (notaNum >= 6 &&
{
sgy = 'D';
}
if (notaNum >= 1 &&
{
sgy = 'F';
}
return sgy;
notaNum <= 8.99)
notaNum <= 7.99)
notaNum <= 6.99)
notaNum <= 5.99)
}
----------------------------------------------------------------------------------//Ejercicio 41
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void conversion(char caracter, int *cont);
void main()
{
char caracter;
int cont = 0;
{
system("cls");
printf("Ingrese una caracter: ");
caracter = getchar();
while (getchar() != '\n'); //Limpia el buffer de teclado
conversion(caracter, &cont);
}
system("Pause");
}
void conversion(char caracter, int *cont)
{
char convert;
if (caracter >= 65 && caracter <= 122)
{
{
convert = (caracter + 32);
}
else
{
{
convert = (caracter - 32);
88
}
}
printf("\nEl caracter invertido es: %c\n\n", convert);
}
else
{
printf("Ingreso un caracter invalido, intente nuevamente...");
*cont = *cont - 1;
getch();
}
}
------------------------------------------------------------------------------//Ejercicio 42
#include
#include
#include
#include
<stdio.h>
<stdlib.h>
<conio.h>
<math.h>
void calculo(float a, float b, float c, float b1, float discri);

void main()
{
float a = 0, b = 0, c = 0;
float b1 = 0, discri = 0;
do
{
system("cls");
printf("Ingrese el valor de a: ");
scanf("%f", &a);
printf("Ingrese el valor de b: ");
scanf("%f", &b);
printf("Ingrese el valor de c: ");
scanf("%f", &c);
b1 = b*(-1);
discri = (b*b) - 4 * a*c;
if (discri > 0)
{
calculo(a, b, c, b1, discri);
}
else
{
system("cls");
printf("No hay raices reales para la ecuacion...");
getch();
}
} while (discri < 0);
}
void calculo(float a, float b, float c, float b1, float discri)
{
float x1pos = 0, x2neg = 0;
x1pos = (b1 + sqrt(discri)) / (2 * a);
x2neg = (b1 - sqrt(discri)) / (2 * a);
system("cls");
printf("Valores ingresados:\n\na: %.2f\nb: %.2f\nc: %.2f\n\n", a, b, c);
89
printf("Resultados:\n\nX1: %.4f\nX2: %.4f\nDiscriminante: %.2f", x1pos,

x2neg, discri);
getch();
}
-------------------------------------------------------------------------------//Ejercicio 44
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int long unsigned func_factA(int P);
void func_divisor(int PmenosQ, int long unsigned factorialA, int Q, int *cont);
void main()
{
int P = 0, Q = 0, i = 0, PmenosQ = 0, cont = 0;
int long unsigned factorialA = 1;
{
scanf("%d", &P);
scanf("%d", &Q);
if (P >= 0)
{
factorialA = func_factA(P);
PmenosQ = P - Q;
func_divisor(PmenosQ, factorialA, Q, &cont);
}
else
{
nuevamente:\n\n");
cont--;
}
}
system("Pause");
}
int long unsigned func_factA(int P)
{
int i = 0, factorialA = 1;
for (i = P; i >= 1; i--)
{
}
if (P == 0)
{
factorialA = 1;
}
return factorialA;
}
90
void func_divisor(int PmenosQ, int long unsigned factorialA, int Q, int *cont)
{
int j = 0;
float result = 0;
int long unsigned factorialB = 1;
if (PmenosQ >= 0)
{
for (j = PmenosQ; j >= 1; j--)
{
factorialB = factorialB * j;
}
}
else
{
printf("\nERROR: No se pudo calcular el factorial de P - Q , la resta
da un numero negativo, intente nuevamente:\n\n");
getch();
system("cls");
*cont = *cont - 1;
}
}
----------------------------------------------------------------------------------// Ejercicio 45
#include <stdio.h>
#include <stdlib.h>
void func_esp(int num, int i);
void func_tabu(int i);
void main()
{
int num = 0, i = 0;
scanf("%d", &num);
printf("\n");
for (i = 0; i <= num - 1; i++)
{
func_esp(num, i);
func_tabu(i);
printf("\n");
}
printf("\n");
system("Pause");
}
91
void func_esp(int num, int i)

{
int k = 0;
for (k = num - 1; k >= i; k--)
{
printf(" ");
}
}
void func_tabu(int i)
{
int j = 0;
for (j = 0; j <= i * 2; j++)
{
printf("*");
}
}
------------------------------------------------------------------------------// Ejercicio 46
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void func_ejeX(int *x);
void func_ejeY(int *y);
void main()
{
int x = 0, y = 0;
char move = 0;
printf("Mientras juegue a mover el # <W,A,S,D> ; pulse escape para
salir...");
getch();
system("cls");
printf("#");
while (move != 27)
{
move = getch();
if (x > 79)
x = 79;
if (x < 0)
x = 0;
if (y > 24)
y = 24;
if (y < 0)
y = 0;
system("cls");
switch (move)
{
case 100:
case 68:
x++;
func_ejeY(&y);
func_ejeX(&x);
break;
92
case 97:
case 65:
x--;
func_ejeY(&y);
func_ejeX(&x);
break;
case 119:
case 87:
y--;
func_ejeY(&y);
func_ejeX(&x);
break;
case 115:
case 83:
y++;
func_ejeY(&y);
func_ejeX(&x);
break;
default:
func_ejeY(&y);
func_ejeX(&x);
}
}
}
void func_ejeX(int *x)
{
int i = 0;
for (i = 1; i <= *x; i++)
{
printf(" ");
}
printf("#");
}
void func_ejeY(int *y)
{
int i = 0;
for (i = 1; i <= *y; i++)
{
printf("\n");
}
}
93
Cuarta Gua Vectores

//Ejercicio 1
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int resist[5] = { 0 };
int i = 0, total = 0;
for (i = 0; i <= 4; i++)
{
printf("Indique el valor de resistencia R%d: ", i + 1);
scanf("%d", &resist[i]);
total = total + resist[i];
}
system("cls");
printf("..::Valores de resistencias::..\n\n");
for (i = 0; i <= 4; i++)
{
printf("Valor de resistencia R%d: %d\n", i + 1, resist[i]);
}
printf("\nResistencia total: %d", total);
getch();
}
-----------------------------------------------------------------------------------//Ejercicio 2
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int num[5] = { 0 };
int i = 0, mayor = 0, total = 0, prom = 0;
for (i = 0; i <= 4; i++)
{
printf("Ingrese numero: ");
scanf("%d", &num[i]);
if (num[i] > mayor)
{
mayor = num[i];
}
total = total + num[i];
}
prom = total / 5;
system("cls");
printf("..::Resultados::..\n\n");
printf("Promedio de numeros ingresados <%d / 5>: %d\n", total, prom);
printf("Mayor de los numeros ingresados: %d", mayor);
getch();
}
94
//Ejercicio 3
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int inter[1500] = { 0 };
int i = 0, cantInter = 0, limit1 = 0, limit2 = 0, temp = 0;
printf("Ingrese un limite: ");
printf("Ingrese el segundo limite: ");
if (limit2 > limit1)
{
temp = limit1;
limit1 = limit2;
limit2 = temp;
}
getch();
for (i = limit1 - 1; i >= limit2 + 1; i--)
{
inter[i] = i;
}
printf("Numeros intermedios: \n\n");
for (i = limit2 + 1; i <= limit1 - 1; i++)
{
if (i <= limit1 - 2)
printf("%d - ", inter[i]);
else
printf("%d", inter[i]);
}
getch();
}
-----------------------------------------------------------------------------------//Ejercicio 4
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
float nota[6] = { 0 };
float prom = 0, suma = 0;
int i = 0;
for (i = 1; i <= 5; i++)
{
printf("Ingrese la nota del alumno N%c%d: ", 248, i);
scanf("%f", &nota[i]);
suma = suma + nota[i];
}
prom = suma / 5;
system("cls");
printf("El promedio general del curso es de: %.2f", prom);
getch();
}
95
//Ejercicio 5
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int cantVend[21] = { 0 }, sumaVend[16] = { 0 };
int totalUni = 0, mejorVende = 0, mayor = 0, i = 0, o = 0;
for (i = 1; i <= 3; i++)
{
system("cls");
mayor = 0;
printf("..::DIA %d::..\n\n", i);
for (o = 1; o <= 4; o++)
{
printf("Ingrese las unidades vendidas por el vendedor N%c%d: ",
248, o);
scanf("%d", &cantVend[o]);
if (cantVend[o] > mayor)
{
mayor = cantVend[o];
mejorVende = o;
}
sumaVend[o] = sumaVend[o] + cantVend[o];
totalUni = totalUni + cantVend[o];
}
printf("\nEl mejor vendedor del Dia N%c%d es el numero: %d\n", 248, i,
mejorVende);
getch();
}
printf("El total de productos vendidos a lo largo de 15 dias es de: %d
productos.", totalUni);
getch();
}
-----------------------------------------------------------------------------------//Ejercicio 6
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int sueldo[21] = { 0 };
int i = 0, demas = 0, demenos = 0, igual = 0, empleado = 1;
do
{
printf("Ingrese el sueldo del empleado %d: ", empleado);
scanf("%d", &sueldo[empleado]);
if (sueldo[empleado] >= 0)
{
empleado++;
}
96
else
{
printf("\n\nINGRESO VALOR INCORRECTO(Solo valores mayores a $0)
\n\aPor favor, intente nuevamente: \n\n");
sueldo[empleado] = 0;
}
} while (empleado <= 20);
for (i = 1; i <= 20; i++)
{
if (sueldo[i] > 2000)
demas++;
else
{
if (sueldo[i] == 2000)
igual++;
else
demenos++;
}
}
%d/20\nMenos de $2000 pesos: %d/20", demas, igual, demenos);
getch();
}
-----------------------------------------------------------------------------------//Ejercicio 7
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
float nota[16] = { 0 };
int aproba[16] = { 0 };
int i = 0, o = 0;
for (i = 1; i <= 15; i++)
{
printf("%d. Ingrese nota: ", i);
scanf("%f", &nota[i]);
}
printf("\n\nPosiciones de notas mayores a 8");
for (o = 1; o <= 15; o++)
{
if (nota[o] > 8)
{
printf(": %d ", o);
}
}
getch();
}
97
//Ejercicio 8
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int fibo[150] = { 0 };
int varA = 0, varB = 1, i = 0, limite = 0, contFibo = 0;
printf("\n..::SECUENCIA DE FIBONACCI::..\n\n");
fibo[1] = 1;
if (limite > 0)
{
{
fibo[i] = varA + varB;
varB = varA;
varA = fibo[i];
}
{
printf("%d", fibo[i]);
if (i < limite)
{
printf(", ");
}
}
}
else
{
printf("\n\nERROR: Valor incorrecto\n\n");
getch();
}
printf("\n\n");
printf("--------------------------------\n\n");
getch();
}
-----------------------------------------------------------------------------------//Ejercicio 9
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int func_suma(int *primer, int *ultimo)
{
int total = 0;
total = *primer + *ultimo;
return total;
}
98
void main()
{
int numeros[150];
int i = 0, cont = -1, ascen = 0, descen = 0, suma = 0;
do
{
cont++;
printf("Ingrese un numero distinto de 0: ");
scanf("%d", &numeros[cont]);
} while (numeros[cont] != 0);
suma = func_suma(&numeros[0], &numeros[cont - 1]);
for (i = 0; i < cont - 1; i++)
{
if (numeros[i] > numeros[i + 1])
{
descen++;
}
else
{
if (numeros[i] < numeros[i + 1])
{
ascen++;
}
}
}
printf("\n");
if (descen != 0 && ascen == 0)
{
printf("Escala Descendente");
}
if (ascen != 0 && descen == 0)
{
printf("Escala Ascendente");
}
if (descen != 0 && ascen != 0)
{
printf("Escala Desordenados");
}
printf("\nLa suma entre el primer y ultimo numero ingresado es: %d", suma);
getch();
}
----------------------------------------------------------------------------------//Ejercicio 10
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int elem[11] = { 0 };
int i = 0, suma = 0, debajo = 0;
float prom = 0;
unsigned long int producto = 1;
for (i = 0; i < 10; i++)
{
99
printf("%d. Ingrese un numero: ", i + 1);

scanf("%d", &elem[i]);
}
for (i = 0; i < 10; i++)
{
suma = suma + elem[i];
producto = producto * elem[i];
}
prom = suma / 10;
for (i = 0; i < 10; i++)
{
if (elem[i] < prom)
{
debajo++;
}
}
printf("\n");
printf("Suma de elementos: %d\n", suma);
printf("Producto de elementos: %lu\n", producto);
printf("Promedio de elementos: %.2f\n", prom);
printf("Elementos por debajo del promedio: %d", debajo);
getch();
}
----------------------------------------------------------------------------------//Ejercicio 11
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int num[10] = { 0 };
int mostrados[10] = { 0 };
int i = 0, j = 0, repeticiones = 0;
for (i = 0; i < 10; i++)
{
printf("Ingrese numero: ");
scanf("%d", &num[i]);
}
for (i = 0; i < 10; i++)
{
repeticiones = 0;
for (j = 0; j < 10; j++)
{
if (j == i)
continue;
if (num[i] == num[j])
{
repeticiones++;
mostrados[j] = num[i];
}
}
if (repeticiones > 0 && mostrados[i] != num[i])
{
100
printf("El numero %d aparece repetido: %d veces.\n", num[i],

repeticiones);
mostrados[i] = num[i];
}
}
getch();
}
-----------------------------------------------------------------------------------//Ejercicio 12
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int elem[10] = { 0 };
int copia[10] = { 0 };
int descen[10] = { 0 };
int i = 0, j = 0, k = 9, cont = 1, temp = 0;
for (i = 0; i < 10; i++)
{
printf("%d. Ingrese un numero: ", cont);
cont++;
}
for (i = 0; i < 10; i++)
{
copia[i] = elem[i];
}
for (i = 0; i < 10; i++)
{
for (j = i + 1; j < 10; j++)
{
if (elem[j] < elem[i])
{
temp = elem[j];
elem[j] = elem[i];
elem[i] = temp;
}
}
}
printf("\nVector de forma ingresada:\n");
for (i = 0; i < 10; i++)
{
printf("%d", copia[i]);
if (i != 9)
printf(", ");
}
printf("\n\nVector de forma ascendente:\n");
for (i = 0; i < 10; i++)
{
printf("%d", elem[i]);
if (i != 9)
printf(", ");
}
101
for (i = 0; i < 10; i++)

{
descen[i] = elem[k];
k--;
}
printf("\n\nVector de forma descendente:\n");
for (i = 0; i < 10; i++)
{
printf("%d", descen[i]);
if (i != 9)
printf(", ");
}
getch();
}
----------------------------------------------------------------------------------//Ejercicio 13
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int elem[6] = { 0 };
int i = 0, cont = 1, resto = 0;
for (i = 0; i < 6; i++)
{
cont++;
}
printf("\nNumeros pares del vector: ");
for (i = 0; i < 6; i++)
{
resto = elem[i] % 2;
if (resto == 0)
{
if (i != 5)
printf(", ");
}
}
getch();
}
-------------------------------------------------------------------------------//Ejercicio 14
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int elem[6] = { 0 };
102
int i = 0, cont = 1, resto = 0;

for (i = 0; i < 6; i++)
{
cont++;
}
for (i = 0; i < 6; i++)
{
resto = i % 2;
if (resto == 0)
{
if (i != 5)
printf(", ");
}
}
getch();
}
-------------------------------------------------------------------------------//Ejercicio 15
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int vector1[11] = { 0 };
int vector2[11] = { 0 };
int vector3[11] = { 0 };
int i = 0, cont = 1, impar = 1, par = 0;
for (i = 0; i < 10; i++)
{
printf("%d. Ingrese un numero al primer vector: ", cont);
scanf("%d", &vector1[i]);
cont++;
}
printf("\n");
cont = 1;
for (i = 0; i < 10; i++)
{
printf("%d. Ingrese un numero al segundo vector: ", cont);
cont++;
}
for (i = 0; i < 5; i++)
{
vector3[i] = vector1[impar];
impar = impar + 2;
}
for (i = 5; i < 10; i++)
{
vector3[i] = vector2[par];
par = par + 2;
103
}
printf("\nElementos del tercer vector generado:\n\n");
printf("Elementos de posiciones impares del primer vector: ");
for (i = 0; i < 5; i++)
{
printf("%d", vector3[i]);
if (i != 4)
{
printf(" - ");
}
}
printf("\nElementos de posiciones impares del primer vector: ");
for (i = 5; i < 10; i++)
{
if (i != 9)
{
printf(" - ");
}
}
getch();
}
------------------------------------------------------------------------------//Ejercicio 16
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int vector1[7] = { 0 };
int vector2[7] = { 0 };
int vector3[7] = { 0 };
int i = 0, cont = 1;
for (i = 0; i < 6; i++)
{
printf("%d. Ingrese un numero al primer vector: ", cont);
cont++;
}
printf("\n");
cont = 1;
for (i = 0; i < 6; i++)
{
printf("%d. Ingrese un numero al segundo vector: ", cont);
cont++;
}
for (i = 0; i < 6; i++)
{
vector3[i] = vector1[i] * vector2[6 - i];
}
printf("\nElementos del tercer vector generado: ");
104
for (i = 0; i < 6; i++)

{
if (i != 5)
{
printf(" - ");
}
}
getch();
}
---------------------------------------------------------------------------------//Ejercicio 17
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int vector1[11] = { 0 };
for (i = 0; i < 10; i++)
{
printf("%d. Ingrese un numero al vector: ", cont);
cont++;
}
printf("\nElementos invertidos del vector: ");
for (i = 9; i >= 0; i--)
{
if (i != 0)
{
printf(" - ");
}
}
getch();
}
----------------------------------------------------------------------------------//Ejercicio 18
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int numeros[10] = { 0 };
int i = 0, ascen = 0, descen = 0, iguales = 0;
for (i = 0; i < 10; i++)
{
printf("%d.Ingrese un numero: ", i + 1);
scanf("%d", &numeros[i]);
}
105
for (i = 0; i < 10; i++)

{
if (numeros[i] > numeros[i + 1] && i != 9)
{
descen++;
}
else
{
if (numeros[i] < numeros[i + 1] && i != 9)
{
ascen++;
}
else
{
if (numeros[i] == numeros[i + 1] && i != 9)
{
iguales++;
}
}
}
}
printf("\nRESULTADO: ");
if (iguales == 9 && descen == 0 && ascen == 0)
{
printf("1");
}
else
{
if (ascen == 9 && descen == 0)
{
printf("2");
}
else
{
if (descen == 9 && ascen == 0)
{
printf("3");
}
else
{
printf("4");
}
}
}
getch();
}
106
//Ejercicio 19
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int bisiesto(int anio)
{
int resto = 0, check = 0;
if (anio > 0)
{
resto = anio % 4;
if (resto == 0)
{
resto = 0;
resto = anio % 100;
if (resto == 0)
{
resto = 0;
resto = anio % 400;
if (resto == 0)
{
return check = 1;
}
else
{
return check = 0;
}
}
else
{
return check = 1;
}
}
else
{
return check = 0;
}
}
}
void main()
{
int vector[5] = { 0 };
int bisiestos[5] = { 0 };
int i = 0, j = 0, check = -1;
do
{
printf("%d. Ingrese un anio: ", i + 1);
scanf("%d", &vector[i]);
for (j = 0; j < i; j++)
{
if (vector[j] == vector[i])
{
printf("\n\aValor ingresado anteriormente.\n\n");
i--;
break;
}
}
107
if (vector[i] < 1000 || vector[i] > 9999)

{
printf("\n\aSolo valores de cuatro cifras.\n\n");
i--;
}
i++;
} while (i < 5);
for (i = 0; i < 5; i++)
{
check = bisiesto(vector[i]);
if (check == 1)
bisiestos[i] = vector[i];
else
continue;
}
printf("\nAnios bisiestos: ");
for (i = 0; i < 5; i++)
{
if (bisiestos[i] != 0)
{
printf("%d - ", bisiestos[i]);
}
}
getch();
}
----------------------------------------------------------------------------------//Ejercicio 20
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void recargo(float *vector)
{
int i = 0;
for (i = 0; i < 6; i++)
{
vector[i] = vector[i] + (15 * vector[i]) / 100;
}
}
void ordenar(float *vector1, int *posis)
{
int pasada = 0, cambio = 0, i = 0, aux2 = 0;
float aux = 0;
do
{
pasada++;
cambio = 0;
for (i = 0; i < (6 - pasada); i++)
{
if (vector1[i] > vector1[i + 1])
{
aux = vector1[i];
vector1[i] = vector1[i + 1];
vector1[i + 1] = aux;
//Se ordenan sus respectivas posiciones en paralelo
108
aux2 = posis[i];
posis[i] = posis[i + 1];
posis[i + 1] = aux2;
cambio = 1;
}
}
} while (cambio == 1);
}
void main()
{
float vector[6] = { 0 };
int posis[6] = { 1, 2, 3, 4, 5, 6 };
int i = 0;
for (i = 0; i < 6; i++)
{
printf("%d. Ingrese precio: ", i + 1);
scanf("%f", &vector[i]);
}
ordenar(vector, posis);
system("cls");
printf("..::PRODUCTOS::..\n\n");
for (i = 0; i < 6; i++)
{
printf("CODIGO PRODUCTO 0%d - %.2f\n", posis[i], vector[i]);
}
printf("\nPulse una tecla para aplicar recargo...\n\n");
getch();
recargo(vector);
for (i = 0; i < 6; i++)
{
printf("CODIGO PRODUCTO 0%d - +15%% %.2f\n", posis[i], vector[i]);
}
getch();
}
109
Quinta Gua Vectores 2 / Ordenamiento / Punteros / Funciones

//Metodo Burbuja
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int vector1[5] = { 0 };
int i = 0, aux = 0, cambio = 0, pasada = 0;
for (i = 0; i < 5; i++)
{
}
do
{
pasada++;
cambio = 0;
for (i = 0; i < (5 - pasada); i++)
{
if (vector1[i] > vector1[i + 1])
{
aux = vector1[i];
vector1[i] = vector1[i + 1];
vector1[i + 1] = aux;
cambio = 1;
}
}
for (i = 0; i < 5; i++)
{
printf("\n%d", vector1[i]);
}
getch();
}
-------------------------------------------------------------------------- //Ejercicio 1
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void mostrar(int *vector1)
{
int j = 0;
for (j = 0; j < 6; j++)
{
printf("\n%d", vector1[j]);
}
}
110
void ingreso(int *vector1)

{
int i = 0;
for (i = 0; i < 6; i++)
{
}
}
void main()
{
int vector1[6] = { 0 };
ingreso(vector1);
mostrar(vector1);
getch();
}
-------------------------------------------------------------------------- //Ejercicio 2
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void ingreso(int *vector)
{
int i = 0;
for (i = 0; i < 7; i++)
{
}
}
int mayor(int *vector, int *posmayor)
{
int mayor = 0, j = 0;
for (j = 0; j < 7; j++)
{
if (vector[j] > mayor)
{
mayor = vector[j];
*posmayor = j;
}
}
return mayor;
}
void mostrar(int *vector)
{
int j = 0;
for (j = 0; j < 7; j++)
{
printf("%d - ", vector[j]);
}
}
111
void main()
{
int posmayor = 0, mayornum = 0;
ingreso(vector);
mayornum = mayor(vector, &posmayor);
printf("\nEl mayor valor del vector es: %d\nPosicion del valor mayor:
%d\n\n", mayornum, posmayor);
printf("Vector completo: ");
mostrar(vector);
getch();
}
----------------------------------------------------------------------------------//Ejercicio 3
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int mayor(float *vector, int mayor)
{
int j = 0;
for (j = 0; j < 7; j++)
{
if (vector[j] > mayor)
{
mayor = vector[j];
}
}
return mayor;
}
void main()
{
float vector[7] = { 0 };
int i = 0;
float mayorGas = 0, total = 0;
for (i = 0; i < 7; i++)
{
printf("%d.Ingrese el valor de gasto: ", i + 1);
scanf("%f", &vector[i]);
total = total + vector[i];
}
mayorGas = mayor(vector, mayorGas);
printf("\nEl monto gastado mas alto es: $%.2f pesos\nEl monto total gastado
es de: $%.2f pesos.\n", mayorGas, total);
getch();
}
112
//Ejercicio 4
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
{
int j = 0;
for (j = 0; j < 8; j++)
{
if (vector[j] != -1)
{
printf("%d", vector[j]);
if (vector[j + 1] != -1 && j != 7)
{
printf(" - ");
}
}
}
}
void repes(int adic1, int adic2, int *vector, int *repe1, int *repe2, int *pos1, int
*pos2)
{
int k = 0;
for (k = 0; k < 8; k++)
{
if (adic1 == vector[k])
{
(*repe1)++;
pos1[k] = k;
}
if (adic2 == vector[k])
{
(*repe2)++;
pos2[k] = k;
}
}
}
void main()
{
int pos1[8] = { -1, -1, -1, -1, -1, -1, -1, -1 };
int pos2[8] = { -1, -1, -1, -1, -1, -1, -1, -1 };
int i = 0, adic1 = 0, adic2 = 0;
int repe1 = 0, repe2 = 0;
for (i = 0; i < 8; i++)
{
}
printf("\n9.Ingrese el primer adicional: ");
scanf("%d", &adic1);
printf("10.Ingrese el segundo adicional: ");
scanf("%d", &adic2);
repes(adic1, adic2, vector, &repe1, &repe2, pos1, pos2);
printf("\nElemento adicional 1 se repite: %d veces\n", repe1);
printf("Posiciones: ");
113
mostrar(pos1);
printf("\n\nElemento adicional 2 se repite: %d veces\n", repe2);
printf("Posiciones: ");
mostrar(pos2);
getch();
}
-----------------------------------------------------------------------------------//Ejercicio 5
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int vector[20] = { 0 };
int pares[20] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1 };
int impares[20] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1 };
int i = 0, resto = 0;
for (i = 0; i < 20; i++)
{
printf("%d. Ingrese un numero: ", i + 1);
}
for (i = 0; i < 20; i++)
{
resto = vector[i] % 2;
if (resto == 0)
{
pares[i] = vector[i];
}
else
{
impares[i] = vector[i];
}
resto = 0;
}
for (i = 0; i < 20; i++)
{
if (pares[i] != -1)
{
printf("%d", pares[i]);
if (i != 19 && pares[i] != -1)
printf(" - ");
}
}
printf("\nNumeros impares del vector: ");
for (i = 0; i < 20; i++)
{
if (impares[i] != -1)
{
114
printf("%d", impares[i]);
if (i != 19 && impares[i] != -1)
printf(" - ");
}
}
getch();
}
----------------------------------------------------------------------------------//Ejercicio 6
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int func_repes(int num, int *vector)
{
int i = 0, repes = 0;
for (i = 0; i < 10; i++)
{
if (num == vector[i])
{
repes++;
}
}
return repes;
}
void func_mayor(int *mayor, int *menor, int *vector)
{
int i = 0;
for (i = 0; i < 10; i++)
{
if (vector[i] > *mayor)
{
*mayor = vector[i];
*menor = vector[i];
}
}
}
void func_menor(int *vector, int *menor)
{
int i = 0;
for (i = 0; i < 10; i++)
{
if (vector[i] < *menor)
{
*menor = vector[i];
}
}
}
void main()
{
int vector[10] = { 0 };
int i = 0, mayor = 0, menor = 0, repeMayor = 0, repeMenor = 0;
115
for (i = 0; i < 10; i++)

{
}
func_mayor(&mayor, &menor, vector);
func_menor(vector, &menor);
repeMayor = func_repes(mayor, vector);
repeMenor = func_repes(menor, vector);
printf("\nMayor: %d\nMenor: %d\n", mayor, menor);
printf("\nRepeticiones:\n\nMayor: %d\nMenor: %d", repeMayor - 1, repeMenor 1);
getch();
}
----------------------------------------------------------------------------------//Ejercicio 8
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void ascen(int *vector)
{
int pasada = 0, cambio = 0, aux = 0, i = 0;
do
{
pasada++;
cambio = 0;
for (i = 0; i < (7 - pasada); i++)
{
if (vector[i] > vector[i + 1])
{
aux = vector[i];
vector[i] = vector[i + 1];
vector[i + 1] = aux;
cambio = 1;
}
}
}
{
int i = 0;
for (i = 0; i < 7; i++)
{
printf("%d", vector[i]);
if (i != 6)
printf(" - ");
}
}
116
void main()
{
int i = 0, j = 0, pasada = 0, cambio = 0, aux = 0;
for (i = 0; i < 7; i++)
{
}
ascen(vector);
printf("\nVector ascendente: ");
mostrar(vector);
getch();
}
---------------------------------------------------------------------------------- //Ejercicio 9
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void descen(int *vector)
{
int pasada = 0, cambio = 0, aux = 0, i = 0;
do
{
pasada++;
cambio = 0;
for (i = 0; i < (8 - pasada); i++)
{
if (vector[i] < vector[i + 1])
{
aux = vector[i];
cambio = 1;
}
}
}
{
int i = 0;
for (i = 0; i < 8; i++)
{
printf("%d", vector[i]);
if (i != 7)
printf(" - ");
}
}
117
void main()
{
int i = 0, j = 0;
for (i = 0; i < 8; i++)
{
}
printf("\nVector original: ");
mostrar(vector);
descen(vector);
printf("\nVector descendente: ");
mostrar(vector);
getch();
}
---------------------------------------------------------------------------------//Ejercicio 10
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void decrece(int *vector)
{
do
{
pasada++;
cambio = 0;
for (i = 0; i < (8 - pasada); i++)
{
if (vector[i] < vector[i + 1])
{
aux = vector[i];
cambio = 1;
}
}
}
void creci(int *vector)
{
do
{
pasada++;
cambio = 0;
for (i = 0; i < (8 - pasada); i++)
{
if (vector[i] > vector[i + 1])
{
aux = vector[i];
118
cambio = 1;
}
}
}
void main()
{
int positivos[8] = { 0 };
int negativos[8] = { 0 };
int i = -1;
do
{
i++;
if (vector[i] == 0)
{
printf("\a\nValor incorrecto, no debe ser 0...\n\n");
i--;
}
} while (vector[i] != 0 && i < 7);
for (i = 0; i < 8; i++)
{
if (vector[i] > 0)
positivos[i] = vector[i];
else
negativos[i] = vector[i];
}
decrece(positivos);
creci(negativos);
printf("\nVector positivos decreciente: ");
for (i = 0; i < 8; i++)
{
if (positivos[i] != 0)
{
printf("%d / ", positivos[i]);
}
else
continue;
}
printf("\nVector negativos ascendiente: ");
for (i = 0; i < 8; i++)
{
if (negativos[i] != 0)
{
printf("%d / ", negativos[i]);
}
else
continue;
}
getch();
}
119
//Ejercicio 11
#include
#include
#include
#include
<stdio.h>
<stdlib.h>
<conio.h>
<strings.h>
void main()
{
char pala[20];
int tama = 0, i = 0;
printf("Ingrese una palabra: ");
gets(pala);
tama = strlen(pala);
for (i = tama; i >= 1; i--)
{
printf("%c", pala[i - 1]);
}
getch();
}
---------------------------------------------------------------------------------//Ejercicio 12
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
int palin(int tama, int j, char *palabra)
{
for (i = 0; i <= tama; i++)
{
printf("Comprobando...%c = %c\n", palabra[i], palabra[j]);
if (palabra[i] != palabra[j])
{
printf("\nLa palabra ingresada NO es palindromo.");
break;
}
j--;
cont++;
}
return cont;
}
void main()
{
char palabra[50];
int cont = 0, j = 0;
gets(palabra);
int tama = strlen(palabra) - 1;
j = tama;
printf("\n");
cont = palin(tama, j, palabra);
if (cont - 1 == tama)
printf("\nLa palabra ingresada SI es palindromo.");
getch();
}
120
//Ejercicio 13
#include
#include
#include
#include
<stdio.h>
<string.h>
<stdlib.h>
<conio.h>
void invert(int len, char *palabra)

{
int i = 0, fAtoi = 0;
for (i = 0; i <= len; i++)
{
fAtoi = palabra[i];
if (fAtoi >= 65 && fAtoi <= 90)
{
palabra[i] = (fAtoi + 32);
}
else
{
if (fAtoi >= 97 && fAtoi <= 122)
{
palabra[i] = (fAtoi - 32);
}
}
}
}
void main()
{
char palabra[50];
gets(palabra);
int len = strlen(palabra) - 1;
invert(len, palabra);
printf("\nLa palabra invertida es: %s\n\n", palabra);
getch();
}
---------------------------------------------------------------------------------//Ejercicio 14
#include
#include
#include
#include
<stdio.h>
<stdlib.h>
<string.h>
<conio.h>
void comprueba(int nota, int *suma, int *j)

{
if (nota > 0 && nota <= 10)
{
*suma = *suma + nota;
}
else
{
printf("\n\aERROR: Valor fuera de rango...\n");
(*j)--;
}
121
(*j)++;
}
void check(char *nombre)
{
int fAtoi = 0;
fAtoi = nombre[0];
if (fAtoi >= 97 && fAtoi <= 122)
{
nombre[0] = (fAtoi - 32);
fAtoi = 0;
}
}
void main()
{
char nombre[50];
int i = 0, j = 0, nota = 0, suma = 0;
float promA = 0, promC = 0;
for (i = 0; i < 3; i++)
{
printf("%d. Ingrese nombre de alumno: ", i + 1);
gets(nombre);
check(nombre);
printf("\n");
j = 0;
do
{
printf("%d. Ingrese calificacion de %s: ", j + 1, nombre);
scanf("%d", &nota);
comprueba(nota, &suma, &j);
} while (j < 5);
promA = suma / 5;
suma = 0;
printf("\nPromedio de %s: %.2f", nombre, promA);
promC = promC + promA;
promA = 0;
printf("\n\n");
}
printf("\nPromedio del curso: %.2f", promC / 3);
getch();
}
---------------------------------------------------------------------------------- //Ejercicio 15
#include
#include
#include
#include
<stdio.h>
<stdlib.h>
<string.h>
<conio.h>
void check(int len, char *texto, int *vocalA, int *vocalE, int *vocalI, int *vocalO,
int *vocalU)
{
int i = 0, fAtoi = 0;
for (i = 0; i <= len; i++)
{
fAtoi = texto[i];
switch (fAtoi)
122
{
case 97:
case 65:
(*vocalA)++;
break;
case 101:
case 69:
(*vocalE)++;
break;
case 105:
case 73:
(*vocalI)++;
break;
case 111:
case 79:
(*vocalO)++;
break;
case 117:
case 85:
(*vocalU)++;
break;
}
}
}
void main()
{
char texto[200];
int len = 0, vocalA = 0, vocalE = 0, vocalI = 0, vocalO = 0, vocalU = 0;
printf("Ingrese un texto: ");
gets(texto);
len = strlen(texto) - 1;
check(len, texto, &vocalA, &vocalE, &vocalI, &vocalO, &vocalU);
printf("\nCantidad de veces que aparece la vocal A: %d.\n", vocalA);
printf("Cantidad de veces que aparece la vocal E: %d.\n", vocalE);
printf("Cantidad de veces que aparece la vocal I: %d.\n", vocalI);
printf("Cantidad de veces que aparece la vocal O: %d.\n", vocalO);
printf("Cantidad de veces que aparece la vocal U: %d.\n\n", vocalU);
getch();
}
---------------------------------------------------------------------------------- //Ejercicio 16
#include
#include
#include
#include
<stdio.h>
<stdlib.h>
<string.h>
<conio.h>
void check(char *nomAnti, char *nombre, int anio, float sueldo, int *menor, float
*sueMen)
{
if (*menor == 0)
{
*menor = anio;
*sueMen = sueldo;
strcpy(nomAnti, nombre);
}
123
else
{
if (anio < *menor)
{
*menor = anio;
*sueMen = sueldo;
strcpy(nomAnti, nombre);
}
}
}
void main()
{
char nombre[50];
char nomAnti[50];
int i = 0, anio = 0, menor = 0;
float sueldo = 0, sueMen = 0;
for (i = 0; i < 3; i++)
{
printf("%d.Ingrese un nombre: ", i + 1);
gets(nombre);
printf("\nAnio de ingreso de %s: ", nombre);
scanf("%d", &anio);
printf("Sueldo de %s: ", nombre);
scanf("%f", &sueldo);
check(nomAnti, nombre, anio, sueldo, &menor, &sueMen);
printf("\n");
}
system("cls");
printf("Empleado de mayor antiguedad: %s\n\n", nomAnti);
printf("Anio de ingreso: %d\n", menor);
printf("Sueldo: %.2f", sueMen);
getch();
}
124
Sexta Gua Matrices

//Ejercicio 1
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int matriz[6][5] = { 0 };
int i = 0, j = 0, check = 0;
do
{
do
{
printf("Ingrese valor de fila <Debe ser menor a o igual 6><0
para salir>: ");
scanf("%d", &i);
} while (i > 6 || i < 0);
if (i != 0)
{
do
{
printf("Ingrese valor de columna <Debe ser mayor a 0 y
menor o igual a 5>: ");
scanf("%d", &j);
} while (j <= 0 || j > 5);
printf("Ingrese valor matriz, coordenada %d - %d: ", i, j);
scanf("%d", &matriz[i - 1][j - 1]);
}
printf("\n");
} while (i != 0);
system("cls");
printf("..::MATRIZ RESULTANTE::..\n\n");
for (i = 0; i < 6; i++)
{
if (check == 1)
break;
for (j = 0; j < 5; j++)
{
if (matriz[i][j] == 0)
check = 0;
if (matriz[i][j] != 0)
{
check = 1;
break;
}
}
}
if (check == 1)
{
for (i = 0; i < 6; i++)
{
for (j = 0; j < 5; j++)
{
125
printf("%d", matriz[i][j]);
if (j != 4)
printf(" - ");
}
printf("\n");
}
}
else
{
system("cls");
printf("\tTodos los valores de la matriz resultante son igual a 0.");
}
getch();
}
---------------------------------------------------------------------//Ejercicio 2
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int matriz[3][3] = { 0 };
int i = 0, j = 0;
for (i = 0; i < 3; i++)
{
if ((i + 1) % 2 == 0)
{
printf("Columna PAR. Num Columna: %d\n\n", i + 1);
for (j = 0; j < 3; j++)
{
printf("Ingrese val entero en las coordenadas %d - %d: ",
i + 1, j + 1);
scanf("%d", &matriz[j][i]);
}
printf("\n");
}
}
for (i = 0; i < 3; i++)
{
if ((i + 1) % 2 != 0)
{
printf("Columna IMPAR. Num Columna: %d\n\n", i + 1);
for (j = 0; j < 3; j++)
{
printf("Ingrese val entero en las coordenadas %d - %d: ",
i + 1, j + 1);
}
printf("\n");
}
}
printf("\n..::MATRIZ RESULTANTE::..\n\nC1 C2 C3\n");
126
for (i = 0; i < 3; i++)

{
for (j = 0; j < 3; j++)
{
if (j != 2)
printf(" - ");
}
printf("\n");
}
getch();
}
---------------------------------------------------------------------//Ejercicio 3
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int matriz[5][5] = { 0 };
int i = 0, j = 0, aux = 1;
printf("..::DIAGONAL PRINCIPAL::..\n\n");
for (i = 0; i < 5; i++)
{
printf("Ingrese un valor entero para %d - %d: ", i + 1, j + 1);
scanf("%d", &matriz[i][j]);
j++;
}
printf("\n..::TRIANGULO SUPERIOR::..\n\n");
for (i = 0; i < 4; i++)
{
for (j = aux; j < 5; j++)
{
printf("Ingrese valor entero para: %d - %d: ", i + 1, j + 1);
}
aux++;
}
printf("\n..::TRIANGULO INFERIOR::..\n\n");
aux = 0;
for (i = 1; i < 5; i++)
{
for (j = 0; j <= aux; j++)
{
}
aux++;
}
printf("\n..::MATRIZ RESULTANTE::..\n\n");
for (i = 0; i < 5; i++)
{
printf("\t");
127
for (j = 0; j < 5; j++)

{
if (j != 4)
printf(" - ");
}
printf("\n");
}
getch();
}
---------------------------------------------------------------------//Ejercicio 4
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void mostrar(int matriz[][3])
{
int i = 0, j = 0;
for (i = 0; i < 3; i++)
{
printf("\t");
for (j = 0; j < 3; j++)
{
if (j != 2)
printf(" - ");
}
printf("\n");
}
}
void main()
{
int matriz[3][3] = { 0 };
int i = 0, x = 0, y = 0, z = 0, aux = 0, cambio = 0, pasada = 0;
for (i = 0; i < 3; i++)
{
for (x = 0; x < 3; x++)
{
printf("Ingrese valor entero para: %d - %d: ", i + 1, x + 1);
scanf("%d", &matriz[i][x]);
}
printf("\n");
}
printf("\nIngrese la columna a ordenar <1,2,3>: ");
scanf("%d", &y);
y--;
for (x = 0; x < 3; x++)
{
for (i = x + 1; i < 3; i++)
{
for (y = 0; y < 3; y++)
{
if (matriz[x][y] > matriz[i][y])
{
128
for (z = 0; z < 3; z++)

{
aux = matriz[i][z];
matriz[i][z] = matriz[x][z];
matriz[x][z] = aux;
}
}
}
}
}
printf("\n..::MATRIZ ORDENADA POR COLUMNA::..\n\n");
mostrar(matriz);
do
{
pasada++;
cambio = 0;
for (i = 0; i < 3; i++)
{
for (x = 0; x < (3 - pasada); x++)
{
if (matriz[i][x] > matriz[i][x + 1])
{
aux = matriz[i][x];
matriz[i][x] = matriz[i][x + 1];
matriz[i][x + 1] = aux;
cambio = 1;
}
}
}
printf("\n..::MATRIZ ORDENADA POR FILA::..\n\n");
mostrar(matriz);
getch();
}
---------------------------------------------------------------------//Ejercicio 5
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
{
int i = 0, j = 0;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 6; j++)
{
printf("%d - ", matriz[i][j]);
}
printf("\n");
}
}
129
int recorre(int matriz[][6], int num, int sorteo)

{
int i = 0, j = 0, check = 0;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 6; j++)
{
if (i == sorteo)
{
if (num == matriz[i][j])
check++;
}
}
}
return check;
}
int repe(int matriz[][6], int *repetidos)
{
int i = 0, j = 0, k = 0, h = 0, repes = -1, mayor = -1, mayorNum = 0, aux =
0, contRepes = 0;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 6; j++)
{
repes = -1;
aux = matriz[i][j];
for (h = 0; h < 3; h++)
{
for (k = 0; k < 6; k++)
{
if (aux == matriz[h][k])
repes++;
}
}
if (repes >= mayor)
{
mayor = repes;
if (contRepes != 6)
{
repetidos[contRepes] = matriz[i][j];
}
contRepes++;
}
}
}
return mayorNum;
}
void main()
{
int matriz[3][6] = { 0 };
int i = 0, j = 0, aux = 0, mayor = 0, repetidos[6] = { 0 }, mostrados[6] = {
0 };
printf("Ingrese numeros de 0 a 42 inclusive, no pueden repetirse:\n\n");
for (i = 0; i < 3; i++)
{
aux = 0;
printf("SORTEO: %d\n\n", i + 1);
130
for (j = 0; j < 6; j++)

{
do
{
printf("%d.Ingrese un numero: ", j + 1);
aux = matriz[i][j];
aux = recorre(matriz, aux, i);
} while (matriz[i][j] <= 0 || matriz[i][j] > 42 || aux > 1);
}
printf("\n");
}
mayor = repe(matriz, repetidos);
/*for (i = 0; i < 6; i++)
{
printf("%d - ", repetidos[i]);
for (j = 0; j < 6; j++)
{
if (repetidos[i] == repetidos[j] && j != i)
}
}*/
getch();
}
---------------------------------------------------------------------------------//Ejercicio 6
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
{
int i = 0, j = 0;
for (i = 0; i < 10; i++)
{
printf("\t");
for (j = 0; j < 2; j++)
{
if (matriz[i][0] != 0)
{
if (j != 1)
printf(" | ");
}
}
printf("\n");
}
}
void ordenar(int matriz[][2])
{
int x = 0, i = 0, y = 0, z = 0, aux = 0;
for (x = 0; x < 10; x++)
{
131
for (i = x + 1; i < 10; i++)

{
for (y = 0; y < 2; y++)
{
if (y == 1)
{
{
for (z = 0; z < 2; z++)
{
aux = matriz[i][z];
matriz[x][z] = aux;
}
}
}
}
}
}
}
void main()
{
int socios[10][2] = { 0 };
int i = 0;
do
{
printf("%d.Ingrese numero de socio: ", i + 1);
scanf("%d", &socios[i][0]);
if (socios[i][0] == 0)
break;
printf("%d.Ingrese edad de socio N%d: ", i + 1, socios[i][0]);
i++;
printf("\n");
} while (socios[i - 1][0] != 0 && i < 10);
printf("\n
Socio | Edad\n");
ordenar(socios);
mostrar(socios);
getch();
}
----------------------------------------------------------------------------------//Ejercicio 7
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int main()
{
int matriz[4][2] = { 0 };
int resul[4][6] = { 0 };
int repetidos[4] = { 0 };
int i = 0, j = 0, oper = 0, mayor = 0, posMayor = 0, valMayor = 0, repes = 1, cont = 0;
132
for (i = 0; i < 4; i++)

{
do
{
system("cls");
printf("%d.Ingrese numero de cliente: ", i + 1);
scanf("%d", &matriz[i][0]);
if (matriz[i][0] <= 0 || matriz[i][0] > 100)
{
printf("\nError: Numero de socio incorrecto, solo de 0 a
100...\n\n");
getch();
}
} while (matriz[i][0] <= 0 || matriz[i][0] > 100);
resul[i][0] = matriz[i][0];
do
{
do
{
system("cls");
printf("\nIngrese codigo de transaccion <0 para
salir>:\n\n");
printf("0. Salir\n1. Deposito\n2. Extraccion\n3.
Comisiones deducidas\n4. Intereses acreditados\n\nOpcion:
");
scanf("%d", &oper);
} while (oper > 4 || oper < 0);
if (oper == 0)
break;
printf("\nIngrese monto de operacion a realizar: ");
switch (oper)
{
case 0:
break;
case 1:
resul[i][1] = resul[i][1] + matriz[i][1];
break;
case 2:
if (matriz[i][1] <= resul[i][1])
resul[i][2] = resul[i][2] - matriz[i][1];
else
{
printf("\nNo hay saldo suficiente en su cuenta,
intente nuevamente.\n");
getch();
}
break;
case 3:
else
{
printf("\nNo hay saldo suficiente en su cuenta,
intente nuevamente.\n");
getch();
}
break;
133
case 4:
break;
default:
printf("\nOpcion incorrecta...\n\n");
getch();
break;
}
} while (oper != 0);
}
for (i = 0; i < 4; i++)
{
for (j = 1; j < 5; j++)
{
resul[i][5] = resul[i][5] + resul[i][j];
}
}
for (i = 0; i < 4; i++)
{
if (resul[i][1] > mayor)
{
mayor = resul[i][1];
posMayor = resul[i][0];
valMayor = i;
}
}
for (i = 0; i < 4; i++)
{
if (mayor == resul[i][1] && mayor != 0)
repetidos[i] = i + 1;
}
printf("\nCliente | Depositos|Extracciones|Comisiones|Intereses|Saldo\n\n");
for (i = 0; i < 4; i++)
{
for (j = 0; j < 6; j++)
{
printf(" %d
", resul[i][j]);
if (j != 5)
printf(" | ");
}
printf("\n");
}
printf("\n\nLos clientes con el deposito maximo son: ");
for (i = 0; i < 4; i++)
{
if (repetidos[i] != 0)
{
printf("%d", repetidos[i]);
}
if (repetidos[i + 1] != 0 && repetidos[i] != 0)
printf(" - ");
}
printf("\nCantidad maxima depositada: %d", mayor);
getch();
}
134
Sexta Gua Matrices (Funciones)

//Ejercicio 1
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
{
int i = 0, j = 0;
for (i = 0; i < 6; i++)
{
for (j = 0; j < 5; j++)
{
if (j != 4)
printf(" - ");
}
printf("\n");
}
}
int chequeo(int matriz[][5])
{
int i = 0, j = 0, check = 0;
for (i = 0; i < 6; i++)
{
if (check == 1)
break;
for (j = 0; j < 5; j++)
{
if (matriz[i][j] == 0)
check = 0;
if (matriz[i][j] != 0)
{
check = 1;
break;
}
}
}
return check;
}
void main()
{
int matriz[6][5] = { 0 };
int i = 0, j = 0, check = 0;
do
{
do
{
printf("Ingrese valor de fila <Debe ser menor a o igual 6><0
para salir>: ");
scanf("%d", &i);
} while (i > 6 || i < 0);
135
if (i != 0)
{
do
{
printf("Ingrese valor de columna <Debe ser mayor a 0 y
menor o igual a 5>: ");
scanf("%d", &j);
} while (j <= 0 || j > 5);
printf("Ingrese valor matriz, coordenada %d - %d: ", i, j);
scanf("%d", &matriz[i - 1][j - 1]);
}
printf("\n");
} while (i != 0);
system("cls");
printf("..::MATRIZ RESULTANTE::..\n\n");
check = chequeo(matriz);
if (check == 1)
{
mostrar(matriz);
}
else
{
system("cls");
printf("\tTodos los valores de la matriz resultante son igual a 0.");
}
getch();
}
---------------------------------------------------------------------//Ejercicio 2
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
{
int i = 0, j = 0;
printf("\n..::MATRIZ RESULTANTE::..\n\nC1
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
if (j != 2)
printf(" - ");
}
printf("\n");
}
}
void pares(int matriz[][3])
{
int i = 0, j = 0;
for (i = 0; i < 3; i++)
{
C2
C3\n");
136
if ((i + 1) % 2 == 0)
{
printf("Columna PAR. Num Columna: %d\n\n", i + 1);
for (j = 0; j < 3; j++)
{
printf("Ingrese valor entero en las coordenadas %d - %d:
", i + 1, j + 1);
}
printf("\n");
}
}
}
void impares(int matriz[][3])
{
int i = 0, j = 0;
for (i = 0; i < 3; i++)
{
if ((i + 1) % 2 != 0)
{
printf("Columna IMPAR. Num Columna: %d\n\n", i + 1);
for (j = 0; j < 3; j++)
{
printf("Ingrese valor entero en las coordenadas %d - %d:
", i + 1, j + 1);
}
printf("\n");
}
}
}
void main()
{
int matriz[3][3] = { 0 };
int i = 0, j = 0;
pares(matriz);
impares(matriz);
mostrar(matriz);
getch();
}
---------------------------------------------------------------------//Ejercicio 3
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
{
int i = 0, j = 0;
printf("\n..::MATRIZ RESULTANTE::..\n\n");
for (i = 0; i < 5; i++)
{
printf("\t");
for (j = 0; j < 5; j++)
{
137
if (j != 4)
printf(" - ");
}
printf("\n");
}
}
void diagPrin(int matriz[][5])
{
int i = 0, j = 0;
printf("..::DIAGONAL PRINCIPAL::..\n\n");
for (i = 0; i < 5; i++)
{
printf("Ingrese un valor entero para %d - %d: ", i + 1, j + 1);
j++;
}
}
void triangSup(int matriz[][5])
{
int i = 0, j = 0, aux = 1;
printf("\n..::TRIANGULO SUPERIOR::..\n\n");
for (i = 0; i < 4; i++)
{
for (j = aux; j < 5; j++)
{
}
aux++;
}
}
void triangInf(int matriz[][5])
{
int i = 0, j = 0, aux = 0;
printf("\n..::TRIANGULO INFERIOR::..\n\n");
aux = 0;
for (i = 1; i < 5; i++)
{
for (j = 0; j <= aux; j++)
{
}
aux++;
}
}
void main()
{
int matriz[5][5] = { 0 };
int i = 0, j = 0, aux = 1;
diagPrin(matriz);
triangSup(matriz);
triangInf(matriz);
mostrar(matriz);
getch();
}
138
//Ejercicio 4
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
{
int i = 0, j = 0;
for (i = 0; i < 3; i++)
{
printf("\t");
for (j = 0; j < 3; j++)
{
if (j != 2)
printf(" - ");
}
printf("\n");
}
}
void ordenCol(int matriz[][3], int y)
{
int i = 0, x = 0, z = 0, aux = 0;
for (x = 0; x < 3; x++)
{
for (i = x + 1; i < 3; i++)
{
for (y = 0; y < 3; y++)
{
{
for (z = 0; z < 3; z++)
{
aux = matriz[i][z];
matriz[x][z] = aux;
}
}
}
}
}
}
void ordenFil(int matriz[][3])
{
int i = 0, x = 0, aux = 0, cambio = 0, pasada = 0;
do
{
pasada++;
cambio = 0;
for (i = 0; i < 3; i++)
{
for (x = 0; x < (3 - pasada); x++)
{
if (matriz[i][x] > matriz[i][x + 1])
{
aux = matriz[i][x];
matriz[i][x] = matriz[i][x + 1];
139
matriz[i][x + 1] = aux;
cambio = 1;
}
}
}
}
void main()
{
int matriz[3][3] = { 0 };
int i = 0, x = 0, y = 0;
for (i = 0; i < 3; i++)
{
for (x = 0; x < 3; x++)
{
printf("Ingrese valor entero para: %d - %d: ", i + 1, x + 1);
scanf("%d", &matriz[i][x]);
}
printf("\n");
}
printf("\nIngrese la columna a ordenar <1,2,3>: ");
scanf("%d", &y);
y--;
ordenCol(matriz, y);
printf("\n..::MATRIZ ORDENADA POR COLUMNA::..\n\n");
mostrar(matriz);
ordenFil(matriz);
printf("\n..::MATRIZ ORDENADA POR FILA::..\n\n");
mostrar(matriz);
getch();
}
---------------------------------------------------------------------//Ejercicio 5
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
{
int i = 0, j = 0;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 6; j++)
{
printf("%d - ", matriz[i][j]);
}
printf("\n");
}
}
int recorre(int matriz[][6], int num, int sorteo)
{
int i = 0, j = 0, check = 0;
for (i = 0; i < 3; i++)
{
140
for (j = 0; j < 6; j++)

{
if (i == sorteo)
{
if (num == matriz[i][j])
check++;
}
}
}
return check;
}
int repe(int matriz[][6], int *repetidos)
{
int i = 0, j = 0, k = 0, h = 0, repes = -1, mayor = -1, mayorNum = 0, aux =
0, contRepes = 0;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 6; j++)
{
repes = -1;
aux = matriz[i][j];
for (h = 0; h < 3; h++)
{
for (k = 0; k < 6; k++)
{
if (aux == matriz[h][k])
repes++;
}
}
if (repes >= mayor)
{
mayor = repes;
if (contRepes != 6)
{
repetidos[contRepes] = matriz[i][j];
}
contRepes++;
}
}
}
return mayorNum;
}
void main()
{
int matriz[3][6] = { 0 };
int i = 0, j = 0, aux = 0, mayor = 0, repetidos[6] = { 0 }, mostrados[6] = {
0 };
printf("Ingrese numeros de 0 a 42 inclusive, no pueden repetirse:\n\n");
for (i = 0; i < 3; i++)
{
aux = 0;
printf("SORTEO: %d\n\n", i + 1);
for (j = 0; j < 6; j++)
{
do
{
printf("%d.Ingrese un numero: ", j + 1);
141
aux = matriz[i][j];
aux = recorre(matriz, aux, i);
} while (matriz[i][j] <= 0 || matriz[i][j] > 42 || aux > 1);
}
printf("\n");
}
mayor = repe(matriz, repetidos);
for (i = 0; i < 6; i++)
{
printf("%d - ", repetidos[i]);
for (j = 0; j < 6; j++)
{
//if (repetidos[i] == repetidos[j] && j != i)
}
}
getch();
}
----------------------------------------------------------------------------------//Ejercicio 6
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
{
int i = 0, j = 0;
for (i = 0; i < 10; i++)
{
printf("\t");
for (j = 0; j < 2; j++)
{
if (matriz[i][0] != 0)
{
if (j != 1)
printf(" | ");
}
}
printf("\n");
}
}
void ordenar(int matriz[][2])
{
int x = 0, i = 0, y = 0, z = 0, aux = 0;
for (x = 0; x < 10; x++)
{
for (i = x + 1; i < 10; i++)
{
for (y = 0; y < 2; y++)
{
if (y == 1)
{
142

{
for (z = 0; z < 2; z++)
{
aux = matriz[i][z];
matriz[x][z] = aux;
}
}
}
}
}
}
}
void main()
{
int socios[10][2] = { 0 };
int i = 0;
do
{
printf("%d.Ingrese numero de socio: ", i + 1);
if (socios[i][0] == 0)
break;
printf("%d.Ingrese edad de socio N%d: ", i + 1, socios[i][0]);
i++;
printf("\n");
} while (socios[i - 1][0] != 0 && i < 10);
printf("\n
Socio | Edad\n");
ordenar(socios);
mostrar(socios);
getch();
}
----------------------------------------------------------------------------------//Ejercicio 7
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int menu()
{
int oper = 0;
do
{
system("cls");
printf("\nIngrese codigo de transaccion <0 para salir>:\n\n");
printf("0. Salir\n1. Deposito\n2. Extraccion\n3. Comisiones
deducidas\n4. Intereses acreditados\n\nOpcion: ");
scanf("%d", &oper);
} while (oper > 4 || oper < 0);
return oper;
}
143
void operac(int resul[][6], int matriz[][2], int oper)

{
int i = 0;
switch (oper)
{
case 0:
break;
case 1:
break;
case 2:
else
{
printf("\nNo hay saldo suficiente en su cuenta, intente
nuevamente.\n");
getch();
}
break;
case 3:
else
{
printf("\nNo hay saldo suficiente en su cuenta, intente
nuevamente.\n");
getch();
}
break;
case 4:
break;
default:
printf("\nOpcion incorrecta...\n\n");
getch();
break;
}
}
int mayorF(int resul[][6], int *mayor, int *posMayor, int valMayor)
{
int i = 0;
for (i = 0; i < 4; i++)
{
if (resul[i][1] > *mayor)
{
*mayor = resul[i][1];
*posMayor = resul[i][0];
valMayor = i;
}
}
return valMayor;
}
void mostrarM(int resul[][6])
{
int i = 0, j = 0;
144
for (i = 0; i < 4; i++)

{
for (j = 0; j < 6; j++)
{
printf(" %d
", resul[i][j]);
if (j != 5)
printf(" | ");
}
printf("\n");
}
}
void main()
{
int matriz[4][2] = { 0 };
int resul[4][6] = { 0 };
int repetidos[4] = { 0 };
int i = 0, j = 0, oper = 0, mayor = 0, posMayor = 0, valMayor = 0, repes = 1, cont = 0;
for (i = 0; i < 4; i++)
{
do
{
system("cls");
printf("%d.Ingrese numero de cliente: ", i + 1);
if (matriz[i][0] <= 0 || matriz[i][0] > 100)
{
printf("\nError: Numero de socio incorrecto, solo de 0 a
100...\n\n");
getch();
}
} while (matriz[i][0] <= 0 || matriz[i][0] > 100);
resul[i][0] = matriz[i][0];
do
{
oper = menu();
if (oper == 0)
break;
printf("\nIngrese monto de operacion a realizar: ");
operac(resul, matriz, oper);
} while (oper != 0);
}
for (i = 0; i < 4; i++)
{
for (j = 1; j < 5; j++)
{
resul[i][5] = resul[i][5] + resul[i][j];
}
}
valMayor = mayorF(resul, &mayor, &posMayor, valMayor);
for (i = 0; i < 4; i++)
{
if (mayor == resul[i][1] && mayor != 0)
repetidos[i] = i + 1;
}
145
printf("\nCliente | Depositos|Extracciones|Comisiones|Intereses|Saldo\n\n");
mostrarM(resul);
printf("\n\nLos clientes con el deposito maximo son: ");
for (i = 0; i < 4; i++)
{
if (repetidos[i] != 0)
{
printf("%d", repetidos[i]);
}
if (repetidos[i + 1] != 0 && repetidos[i] != 0)
printf(" - ");
}
printf("\nCantidad maxima depositada: %d", mayor);
getch();
}
146
Evaluacin Matrices Introduccin a Matrices

//Ejercicio 1
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int matriz[2][3];
int i = 0, j = 0;
for (j = 0; j < 2; j++)
{
printf("Fila %d:\n\n", j+1);
for (i = 0; i < 3; i++)
{
printf("Fila %d: Ingrese valor columna %d: ", j+1, i+1);
}
printf("\n");
}
printf("Matriz resultante:\n\n");
for (j = 0; j < 2; j++)
{
for (i = 0; i < 3; i++)
{
printf("%d", matriz[j][i]);
if (i != 2)
printf(" - ");
}
printf("\n");
}
getch();
}
-------------------------------------------------------------------------------------//Ejercicio 2
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int matriz[2][3];
int i = 0, j = 0;
for (j = 0; j < 2; j++)
{
for (i = 0; i < 3; i++)
{
147
}
printf("\n");
}
for (j = 0; j < 2; j++)
{
for (i = 0; i < 3; i++)
{
if (j == 0)
matriz[j][i] = matriz[j][i]*4;
if (j == 1)
}
}
printf("Matriz resultante:\n\n");
for (j = 0; j < 2; j++)
{
for (i = 0; i < 3; i++)
{
if (i != 2)
printf(" - ");
}
printf("\n");
}
getch();
}
-------------------------------------------------------------------------------------//Ejercicio 3
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int matriz[2][3] = {0};
int i = 0, j = 0, suma = 0, mayor = 0, menorElem = 0;
for (j = 0; j < 2; j++)
{
for (i = 0; i < 3; i++)
{
}
printf("\n");
}
for (j = 0; j < 2; j++)
{
for (i = 0; i < 3; i++)
{
if (j == 0)
if (j == 1)
}
148
}
for (j = 0; j < 2; j++)
{
for (i = 0; i < 3; i++)
{
if (matriz[j][i] > mayor)
mayor = matriz[j][i];
}
}
for (j = 0; j < 2; j++)
{
for (i = 0; i < 3; i++)
{
if (j == 0 && i == 0)
{
if (matriz[j][i] < mayor)
{
menorElem = matriz[j][i];
}
}
else
{
if (matriz[j][i] < menorElem)
{
menorElem = matriz[j][i];
}
}
}
}
for (j = 0; j < 2; j++)
{
for (i = 0; i < 3; i++)
{
suma = suma + matriz[j][i];
}
}
printf("-------------------------\nMatriz resultante:\n\n");
for (j = 0; j < 2; j++)
{
for (i = 0; i < 3; i++)
{
if (i != 2)
printf(" - ");
}
printf("\n");
}
printf("\nMenor elemento de matriz modificada: %d\n", menorElem);
printf("Suma total de todos los elementos modificados: %d", suma);
getch();
}
149
//Ejercicio 4
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int matriz[3][12] = {0};
float recau[3][12] = {0};
float recauL = 0;
float recauC = 0;
float total = 0;
int i = 0, j = 0;
for (j = 0; j < 3; j++)
{
printf("Linea %d:\n\n", j+1);
i = 0;
do
{
printf("Linea %d: Ingrese numero de coche <menor a 1 para
finalizar> %d: ", j+1, i+1);
if(matriz[j][i] > 12)
{
printf("\n\aNumero de coche incorrecto, debe ser menor a
12.\n\n");
i--;
}
i++;
}
while (matriz[j][i-1] >= 1 && matriz[j][i-1] <= 12 && i < 12);
printf("\n");
}
printf("..::RECAUDACIONES::..\n\n");
for (j = 0; j < 3; j++)
{
recauL = 0;
for (i = 0; i < 12; i++)
{
recauC = 0;
if (matriz[j][i] != 0)
{
printf("Ingrese tarifa del coche Linea %d - Coche %d: ",
j+1, matriz[j][i]);
scanf("%f", &recau[j][i]);
printf("Recaudacion Coche: %.2f\n\n", recau[j][i]);
}
recauL = recauL + recau[j][i];
}
total = total + recauL;
printf("-----------------------\nRecaudacion Linea %d: %.2f\n----------------------", j+1, recauL);
printf("\n\n");
}
printf("\nTotal recaudacion: %.2f", total);
getch();
}
150
//Ejercicio 5
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
float prom[5] = { 0 };
float notas[3][5] = { 0 }, aux = 0, aux2 = 0;
int i = 0, j = 0, opcion = 0, opcion2 = 0, lega = 0, trim = 0;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 5; j++)
{
printf("Trimestre %d. Ingrese la nota del alumno 0%d: ", i + 1,
j + 1);
scanf("%f", &notas[i][j]);
}
printf("\n");
}
do
{
printf("\n\nDesea corregir alguna nota? 1: SI - Otro: NO\n");
printf("Opcion: ");
if (opcion == 1)
{
printf("Ingrese numero de legajo: ");
scanf("%d", &lega);
printf("Ingrese trimestre a corregir <1,2,3>: ");
scanf("%d", &trim);
printf("Ingrese nueva nota: ");
scanf("%f", &aux);
aux2 = notas[trim - 1][lega - 1];
printf("Desea confirmar el cambio de %.2f por %.2f? 1: SI Otro: NO", aux2, aux);
printf("\nOpcion: ");
scanf("%d", &opcion2);
if (opcion2 == 1)
notas[trim - 1][lega - 1] = aux;
}
} while (opcion == 1);
for (i = 0; i < 5; i++)
{
for (j = 0; j < 3; j++)
{
prom[i] = prom[i] + notas[j][i];
}
prom[i] = prom[i] / 3;
}
printf("Num Legajo 1er Trimestre 2do Trimestre 3er trimestre
Promedio\n");
for (i = 0; i < 5; i++)
{
printf("
0%d
", i + 1);
151
for (j = 0; j < 3; j++)

{
printf("\t%.2f\t", notas[j][i]);
}
printf("
%.2f", prom[i]);
printf("\n");
}
getch();
}
-------------------------------------------------- //Ejercicio 6
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
int matriz[20][6] = { 0 };
int i = 0, j = 0, total = 0;
float prom[20] = { 0 };
for (i = 0; i < 20; i++)
{
printf("Piso %d\n\n", i + 1);
for (j = 0; j < 6; j++)
{
printf("Ingrese cantidad de habitantes en la habitacion: 0%d: ",
j + 1);
}
printf("\n");
}
for (i = 0; i < 20; i++)
{
for (j = 0; j < 6; j++)
{
total = total + matriz[i][j];
}
}
for (i = 0; i < 20; i++)
{
for (j = 0; j < 6; j++)
{
prom[i] = prom[i] + matriz[i][j];
}
prom[i] = prom[i] / 6;
}
system("cls");
printf("..::PROMEDIO DE HABITANTES POR PISO::..\n\n");
for (i = 0; i < 20; i++)
{
printf("Piso %d: %.2f\n", i + 1, prom[i]);
}
printf("\nTotal de habitantes en el edificio: %d", total);
getch();
}
152
Trabajo Prctico en Clase Cadenas

Parte Terica
Para qu se utiliza la funcin gets ()? Sintaxis: gets (nombre_variable);
R= La funcin gets() se utiliza para almacenar una cadena de caracteres completa en una variable
de tipo Char.
Para qu se utiliza la funcin puts ()? Sintaxis puts (nombre_variable);
R= La funcin puts() se utiliza para mostrar en pantalla una cadena completa de una variable de
tipo Char, siempre y cuando se utilice solo un argumento y adems realiza un salto de lnea. En
caso de que se vaya a mostrar una variable, solo puede usarse luego de un gets().
Es posible realizar la impresin de una cadena de texto a travs de la funcin printf ()?
R= Si, es posible siempre y cuando se utilice %s dentro del printf en el lugar de la variable a
mostrar.
Se puede utilizar la funcin scanf () para capturar el texto ingresado? Posee alguna
limitacin? Recuerden los distintos especificadores con los que trabaja la funcin!
R= Puede usarse si al momento de usar el scanf si se utiliza el especificador %s por ejemplo:
scanf (%s, &nombre_variable);
La limitacin del scanf es que solo almacena hasta la primera palabra, y con el gets almacena
hasta que se pulsa ENTER.
Qu devuelve la funcin strlen ()? Recuerden que las funciones para manejo de caracteres
pertenecen a la biblioteca <string.h>!
R= La funcin strlen() nos devuelve el tamao usado de una variable de tipo Char en valor
numrico.
De acuerdo al siguiente cdigo:
{
char nombre[100];
char anio[10];
printf("Inrese su nombre:\n");
gets (nombre);
printf("Inrese su ao de nacimiento:\n");
gets (anio);
int dato= atoi(anio);
int diferencia=2012-dato;
153
printf("%s tiene %d aos! \n",nombre,diferencia);

system("pause");
}
Qu podemos decir que realiza la funcin atoi()?

154
R= Podemos decir que la funcin atoi() convierte una variable de tipo Char a una variable de tipo
Int.
Qu Sucede si en el ejemplo anterior ingresamos un valor no valido?
R= Si en el ejemplo anterior ingresamos un valor no valido, por ejemplo una letra o smbolo, la
funcin atoi() asigna a la variable el valor de 0.
Qu devuelve la funcin strcmp ()? Esta funcin, a diferencia de las anteriores recibe como
argumento dos cadenas.
R= Esta funcin lo que hace es comparar el tamao de dos variables, si la primer variable dentro
del strcmp() es mayor que la segunda variable, nos devolver el valor de 1, en caso de que la
segunda variable sea mayor que la primera, nos devolver el valor -1, y si ambas son iguales, nos
devolver 0.
Parte Prctica
//Ejercicio 10:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void main()
{
int i = 0;
char nombre[100];
printf("Ingrese su nombre:\n\n");
gets(nombre);
int len = strlen(nombre);
for (i = len; i >= 1; i--)
{
printf("%c", nombre[i - 1]);
}
printf("\n\n");
system("Pause");
}
//Ejercicio 11:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
char palabra[50];
char copia[50];
int i = 0;
gets(palabra);
strcpy(copia, palabra);
strrev(copia);
int igualdad = strcmp(palabra, copia);
if (igualdad == 0)
{
printf("\nLa palabra ingresada SI es palindromo.\n\n");
}
else
{
printf("\nLa palabra ingresada NO es palindromo.\n\n");
}
system("Pause");
}
-----------------------------------------------------//Ejercicio 12:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
char palabra[50];
char convert[50];
int i = 0;
int fAtoi = 0;
gets(palabra);
for (i = 0; i <= len; i++)
{
fAtoi = palabra[i];
if (fAtoi >= 65 && fAtoi <= 90)
{
palabra[i] = (fAtoi + 32);
}
else
{
if (fAtoi >= 97 && fAtoi <= 122)
{
palabra[i] = (fAtoi - 32);
}
155
}
}
printf("\nLa palabra invertida es: %s\n\n", palabra);
system("Pause");
}
-----------------------------------------------------//Ejercicio 13:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void main()
{
int i = 0, cont = 0, numNota = 0, calific, fAtoi = 0, len = 0;
float promAlum = 0.0, promCurso = 0.0, promParcial = 0.0;
char nombre[100];
{
printf("Ingrese el apellido del alumno: ");
scanf("%s", nombre);
printf("\n");
len = strlen(nombre);
fAtoi = nombre[0];
if (fAtoi >= 97 && fAtoi <= 122)
{
nombre[0] = (fAtoi - 32);
len = 0;
fAtoi = 0;
}
for (i = 1; i <= 5; i++)
{
numNota = numNota++;
printf("Ingrese nota %d de alumno %s: ", numNota, nombre);
{
if (i == 5)
{
promParcial = 0;
printf("\nPromedio del alumno %s es de: %.2f
\n\n", nombre, promAlum);
numNota = 0;
}
}
else
{
10). \n\aPor favor, ingrese nuevamente:\n\n");
numNota--;
calific = 0;
i--;
156
}
}
}
printf("\nPromedio general del curso: %.2f\n\n", promCurso);
system("Pause");
}
-----------------------------------------------------//Ejercicio 14:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void main()
{
char texto[200];
int i = 0, len = 0, fAtoi = 0, vocalA = 0, vocalE = 0, vocalI = 0, vocalO =
0, vocalU = 0;
printf("Ingrese un texto: ");
gets(texto);
len = strlen(texto) - 1;
for (i = 0; i <= len; i++)
{
fAtoi = texto[i];
switch (fAtoi)
{
case 97:
case 65:
vocalA++;
break;
case 101:
case 69:
vocalE++;
break;
case 105:
case 73:
vocalI++;
break;
case 111:
case 79:
vocalO++;
break;
case 117:
case 85:
vocalU++;
break;
}
}
printf("\nCantidad de veces que aparece la vocal A: %d.\n", vocalA);
printf("Cantidad de veces que aparece la vocal E: %d.\n", vocalE);
printf("Cantidad de veces que aparece la vocal I: %d.\n", vocalI);
printf("Cantidad de veces que aparece la vocal O: %d.\n", vocalO);
printf("Cantidad de veces que aparece la vocal U: %d.\n\n", vocalU);
system("Pause");
}
157
//Ejercicio 15
#include
#include
#include
#include
<stdio.h>
<stdlib.h>
<conio.h>
<string.h>
void antiguo(int fecha[][3], int *posAnt)

{
int AnioAnt = fecha[0][2];
int MesAnt = fecha[0][1];
int DiaAnt = fecha[0][0];
int i = 0;
for (i = 0; i < 3; i++)
{
if (fecha[i][2] < AnioAnt)
{
AnioAnt = fecha[i][2];
*posAnt = i;
}
else
{
if (fecha[i][1] < MesAnt)
{
MesAnt = fecha[i][1];
*posAnt = i;
}
else
{
if (fecha[i][0] < DiaAnt)
{
DiaAnt = fecha[i][0];
*posAnt = i;
}
}
}
}
}
void main()
{
char empleados[3][50];
float sueldo[3] = { 0 };
int fecha[3][3] = { 0 };
int i = 0, j = 0, masAnt = 0, posAnt = 0;
for (i = 0; i < 3; i++)
{
printf("Ingrese nombre del empleado N%d: ", i + 1);
gets(empleados[i]);
}
for (i = 0; i < 3; i++)
{
printf("Ingrese sueldo del empleado N%d: ", i + 1);
scanf("%f", &sueldo[i]);
}
for (i = 0; i < 3; i++)
{
printf("\nFecha de ingreso del empleado N%d:\n\n", i + 1);
printf("Anio: ");
158
scanf("%d", &fecha[i][2]);
printf("Mes: ");
printf("Dia: ");
}
antiguo(fecha, &posAnt);
printf("\nEl empleado mas antiguo es: ");
puts(empleados[posAnt]);
printf("\nCon un sueldo de: %.2f", sueldo[posAnt]);
getch();
}
159
Prctica con funciones en clases

1) Un buque de carga traslada 10 containers a diferentes puertos.Para cada uno de
los conteiners trasladados por el buque se registran los siguientes datos :
Identificacion del container, peso del container en kg y puerto de arribo
identificado del uno al 3.
Se pide calcular e informar el peso total que el buque debe trasladar, el contenedor
de mayor peso, y la cantidad de contenedores que se trasladaran a cada puerto.
-----------------------------------------------------------------------------------//Ejercicio 1
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
float func_mayor(float peso, int *numMayor, int cont);
void func_estadisticas(float pesoTotal, int numMayor, int puerto1, int puerto2, int
puerto3);
void main()
{
int identi = 0, puerto = 0, cont = 0, puerto1 = 0, puerto2 = 0, puerto3 = 0,
numMayor = 0;
float peso = 0, pesoTotal = 0, mayorPeso = 0;
{
system("cls");
printf("..::INGRESO::..\n\n");
printf("Ingrese identificacion del contenedor N:%d: ", cont);
scanf("%d", &identi);
printf("Ingrese peso del container en Kg: ");
scanf("%f", &peso);
do
{
printf("Ingrese el puerto de arribo <1-2-3>: ");
scanf("%d", &puerto);
switch (puerto)
{
case 1:
puerto1++;
break;
case 2:
puerto2++;
break;
case 3:
puerto3++;
break;
default:
printf("\n\aHa ingresado un valor de puerto incorrecto,
solo se admite <1-2-3>...");
getch();
system("cls");
}
160
} while (puerto != 1 && puerto != 2 && puerto != 3);

mayorPeso = func_mayor(peso, &numMayor, cont);
pesoTotal = pesoTotal + peso;
}
system("cls");
printf("Calculos realizados con exito, pulse una tecla para mostrar
estadisticas...");
getch();
func_estadisticas(pesoTotal, numMayor, puerto1, puerto2, puerto3);
system("Pause");
}
float func_mayor(float peso, int *numMayor, int cont)
{
float mayorPeso = 0;
if (peso > mayorPeso)
{
mayorPeso = peso;
*numMayor = cont;
}
return mayorPeso;
}
void func_estadisticas(float pesoTotal, int numMayor, int puerto1, int puerto2, int
puerto3)
{
system("cls");
printf("Peso total a trasladar por el buque: %.2f Kg\n", pesoTotal);
printf("Contenedor de mayor peso: %d \n\n", numMayor);
printf("Contenedores a puerto 1.............. %d\n", puerto1);
printf("Contenedores a puerto 2.............. %d\n", puerto2);
printf("Contenedores a puerto 3.............. %d\n\n", puerto3);
}
-----------------------------------------------------------------------------------2) Se realiza una inspeccion en una fabrica de pintura y se detectaron algunas
infracciones.
De cada infraccion se tomo nota de los siguientes datos : tipo de infraccion(numeros
del 1 al 4),
valor de multa y gravedad de la infraccion(1: leve, 2 : moderado, 3 : grave), el
ingreso finaliza
cuando se ingrese una infraccion con valor a 0. Se pide informar al final del
proceso valores totales
de las multas a pagar.De a cuerdo a la gravedad de las infracciones registradas la
leyenda "Clausurar fabrica"
si la cantidad de infracciones de tipo 3 y 4, con gravedad 3 es mayor a 3; informar
el total de multas a pagar y su valor en pesos.
161
//Ejercicio 2
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void func_valGrav(int grave, float valor, float *valgrav1, float *valgrav2, float
*valgrav3);
void func_estadisticas(float valgrav1, float valgrav2, float valgrav3, int
numInfra);
void func_clausura(int leyenOK);
void main()
{
int tipo = 0, grave = 0, numInfra = 1, leyenOK = 0;
float valor = 0;
float valgrav1 = 0, valgrav2 = 0, valgrav3 = 0;
do
{
do
{
system("cls");
printf("..::INGRESO::..\n\n");
printf("Ingrese el tipo de infraccion N:%d <1-2-3-4>: ",
numInfra);
scanf("%d", &tipo);
} while (tipo != 0 && tipo != 1 && tipo != 2 && tipo != 3 && tipo !=
4);
if (tipo == 0)
{
break;
}
printf("Ingrese el valor de la infraccion: ");
scanf("%f", &valor);
do
{
printf("\nGravedad de la infraccion <1-2-3>...\n\n");
printf("1.Leve\n");
printf("2.Moderado\n");
printf("3.Grave\n\n");
printf("Gravedad: ");
scanf("%d", &grave);
} while (grave != 1 && grave != 2 && grave != 3);
numInfra++;
if (tipo == 3 || tipo == 4 && grave == 3)
{
leyenOK++;
}
func_valGrav(grave, valor, &valgrav1, &valgrav2, &valgrav3);
} while (tipo != 0);
func_estadisticas(valgrav1, valgrav2, valgrav3, numInfra);
func_clausura(leyenOK);
}
162
void func_valGrav(int grave, float valor, float *valgrav1, float *valgrav2, float
*valgrav3)
{
switch (grave)
{
case 1:
*valgrav1 = *valgrav1 + valor;
break;
case 2:
break;
case 3:
break;
}
}
void func_estadisticas(float valgrav1, float valgrav2, float valgrav3, int numInfra)
{
system("cls");
printf("Cantidad de multas ingresadas: ", numInfra);
printf("Valor a pagar de multas gravedad 1 .................. $%.2f
pesos\n", valgrav1);
pesos\n", valgrav2);
pesos\n\n", valgrav3);
system("Pause");
}
void func_clausura(int leyenOK)
{
if (leyenOK > 3)
{
system("cls");
printf("CLAUSURAR FABRICA INMEDIATAMENTE...Pulse una tecla para
clausurar\n\n");
getch();
printf("FABRICA CLAUSURADA CON EXITO, HA HECHO UN BIEN AL
MUNDO!!\n\n");
system("Pause");
}
else
{
system("cls");
printf("No es necesario realizar una clausura...\n\n");
system("Pause");
}
}
163

Guías Prácticas de Algoritmos

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guías Prácticas de Algoritmos

Cargado por

Copyright:

Formatos disponibles

Escuela Tcnica N1 Otto Krause 4to Computacin 2da

Segunda Gua Condiciones compuestas / Switch _______________________________ 6

Prctica con funciones en clases ____________________________________________ 160

Primera Gua Introduccin a variables y condiciones

int r1, r2, r3, r4, r5, rt;

total (Rt) es: %d ohms. \n", rt);

Segunda Gua Condiciones compuestas / Switch

//Se crea variable de tipo float para que el programa

(basico * 10) / 100;

(basico * 20) / 100;

total = adic1 + adic2 + adic3 + basico;

Tercera Gua Parte 1 Estructuras de control

for (i = 0; i <= 5; i++)

if (ao > 0 && (mes > 0 && mes <= 12))

//Finaliza instruccion SWITCH

printf("\nERROR: La fecha ingresada es invalida.\a\n\n");

//Cuando el promedio es el mas alto se almacena el numero de

printf("\n%d!: ", numero);

printf("\nERROR: P no puede valer menos que 0, intente

if (dia >= 19 && mes == 2 || dia <= 20 && mes == 3)

printf("\nERROR: Ha ingresado una fecha invalida, intente

for (contPpal = 1; contPpal <= 1; contPpal++)

Tercera Gua Parte 1 (Funciones) Estructuras de control

void num2Mayor(int num1, int num2)

printf("Ingrese la potencia: ");

*result = *result - *num2;

cent = num / 100;

for (cont = 1; cont <= 1; cont++)

void func_dibuja(int num)

printf("ADVERTENCIA: Lo quieren estafar... Ingrese nuevamente ambos

printf("%d x ", iFact);

Tercera Gua Parte Dos (Solo Funciones) Estructuras de Control

printf("Instante 2: %d hs - %d min %d segs\n", h2, m2, s2);

float func_apuesta(int *cont, float saldoBanca, float apuestaAct, float

int bisiesto(int mayor, int menor, int dias, int *cantBisi)

if (notaNum >= 8 &&

notaNum <= 8.99)

notaNum <= 7.99)

notaNum <= 6.99)

notaNum <= 5.99)

void calculo(float a, float b, float c, float b1, float discri);

printf("Resultados:\n\nX1: %.4f\nX2: %.4f\nDiscriminante: %.2f", x1pos,

void func_esp(int num, int i)

Cuarta Gua Vectores

printf("%d. Ingrese un numero: ", i + 1);

printf("El numero %d aparece repetido: %d veces.\n", num[i],

for (i = 0; i < 10; i++)

int i = 0, cont = 1, resto = 0;

for (i = 0; i < 6; i++)

for (i = 0; i < 10; i++)

if (vector[i] < 1000 || vector[i] > 9999)

Quinta Gua Vectores 2 / Ordenamiento / Punteros / Funciones

void ingreso(int *vector1)

for (i = 0; i < 10; i++)

void invert(int len, char *palabra)

void comprueba(int nota, int *suma, int *j)

Sexta Gua Matrices

for (i = 0; i < 3; i++)

for (j = 0; j < 5; j++)

for (z = 0; z < 3; z++)

int recorre(int matriz[][6], int num, int sorteo)

for (j = 0; j < 6; j++)

for (i = x + 1; i < 10; i++)

for (i = 0; i < 4; i++)

result = result - *num2;

void comprueba(int nota, int suma, int j)