Los ejercicios resueltos de la siguiente relación no están relacionados con la lista de ejercicios propuestos de cada tema (la cual puedes encontrar aquí).
Si n = 0, n! = 1
Si n > 0, n! = n * (n - 1) * (n - 2) * ... * 3 * 2 * 1
Solución 1: Con un bucle for y variable índice (i).
/****************************/
/* Factorial. */
/****************************/
#include <stdio.h>
void main (void){
unsigned i, n;
unsigned long fact = 1;
printf ("\nEscribe el número: ");
scanf ("%u", &n);
for (i = 2; i <= n; i++)
fact = fact * i;
printf ("El factorial de %u es: %lu.", n, fact);
}
Solución 2: Con un bucle for y sin variable índice.
/****************************/
/* Factorial. */
/****************************/
/* No usa variable índice: Utiliza la misma variable N, decrementándola: */
/* Esto implica que al final la variable N habrá sido modificada. */
#include <stdio.h>
void main(){
unsigned long int N, /* Número del que calcularemos el factorial */
fact=1; /* Factorial calculado */
printf("\nDame el número para calcular su factorial: ");
scanf("%lu", &N);
for (;N>=2; N--)
fact=fact*N;
printf("\nEl factorial es: %lu.\n", fact);
}
Solución 3: Con un bucle while.
/****************************/
/* Factorial. */
/****************************/
#include <stdio.h>
void main(){
unsigned long int N, /* Número del que calcularemos el factorial */
fact=1; /* Factorial calculado */
printf("\nDame el número para calcular su factorial: ");
scanf("%lu", &N);
while (N>=2){
fact=fact*N;
N--;
}
printf("\nEl factorial es: %lu.\n", fact);
}
Solución 4: Con un bucle do-while.
/****************************/
/* Factorial. */
/****************************/
#include <stdio.h>
void main(){
unsigned long int N, /* Número del que calcularemos el factorial */
fact=1; /* Factorial calculado */
printf("\nDame el número para calcular su factorial: ");
scanf("%lu", &N);
if (N>=2)
do {
fact=fact*N;
N--;
} while (N>=2);
printf("\nEl factorial es: %lu.\n", fact);
}
Una empresa maneja códigos numéricos con las siguientes características:
Escriba un programa que lea de teclado un número de cuatro dígitos, y posteriormente imprima en pantalla la siguiente información:
PROVINCIA &
TIPO DE OPERACIÓN &
NÚMERO DE OPERACIÓN &&
En caso de que el número tenga más de 4 dígitos, en lugar del mensaje anterior, habrá que imprimir en pantalla el siguiente mensaje de error: ERROR: CÓDIGO NO VÁLIDO. Si tiene menos de 4 dígitos se suponen 0 los primeros.
Solución:
/***********************/
/* Tema 4: Ejercicio 1 */
/***********************/
#include <stdio.h>
#include <conio.h>
void main() {
int N;
clrscr(); /* Limpiar la pantalla */
printf("Introduce el código numérico: ");
scanf("%d", &N);
if (N>9999) /* El código tiene más de 4 cifras */
printf("ERROR: CÓDIGO NO VÁLIDO.");
else {
printf("PROVINCIA %d\n", N/1000);
printf("TIPO DE OPERACIÓN %d\n", (N % 1000)/100);
if (N%100 <= 9) /* Número de Operación con sólo una cifra */
/* Escribe el 0 del primer dígito delante del número */
printf("NÚMERO DE OPERACIÓN 0%d\n", N%100);
else
printf("NÚMERO DE OPERACIÓN %d\n", N%100);
}
}
Con objeto de fomentar el ahorro energético, el recibo de la electricidad se elabora de forma que el precio de cada Kwh (kilowatio/hora) consumido es más caro cuanto más se consume:
Elabore un programa que lea de teclado los dos últimos valores del contador (lo que marca el contador actualmente y lo que marcaba en la última lectura), y calcule e imprima en pantalla el importe total a pagar.
Solución:
/***********************/
/* Tema 4: Ejercicio 2 */
/***********************/
#include <stdio.h>
void main() {
float C1,C2, recibo;
printf("Escribe el valor del contador anterior al último: ");
scanf("%f", &C1);
printf("Escribe el último valor del contador: ");
scanf("%f", &C2);
if (C1>C2)
printf("ERROR: El último valor es menor que el anterior.");
else {
C1=C2-C1;
if (C1<=100)
recibo=100 + 50*C1;
else if (C1<=250)
recibo= 5100 + 70*(C1-100);
else
recibo= 5100 + 70*150 + 100*(C1-250);
}
printf("- El valor del recibo es %f.\n", recibo);
}
El programa genera un error si el primer valor del contado es mayor que el segundo ya que eso supondría un "consumo negativo". No obstante, también podría considerarse ese caso suponiendo que el contador ha llegado a su valor máximo y ha dado la vuelta empezando de nuevo en el valor cero. Para poder tener eso en cuenta necesitamos saber el número de dígitos del contador o, lo que es lo mismo, el valor máximo del contador.
Efectuar un programa que lea los valores de 3 resistencias electrónicas (en Ohmios, W) conectadas en paralelo y muestre en pantalla el valor global de las 3. El valor global es calculado por la siguiente ecuación: 1 / (1/R1 + 1/R2 + 1/R3).
Modifique el programa anterior para:
Solución:
/***********************/
/* Tema 4: Ejercicio 5 */
/***********************/
#include <stdio.h>
void main() {
int N,i;
float R, Eq_serie=0, Eq_paral=0;
printf("Dime el número de resistencias a conectar: ");
scanf("%d", &N);
if (N==0)
printf("No hay resistencias que conectar.\n");
else {
for(i=1;i<=N;i++) {
/* leer la resistencia hasta que sea mayor que cero */
printf("Introduce la resistencia número %d: ", i);
scanf("%f", &R);
while (R<=0) {
printf("Resistencia menor o igual que cero. Introduce otro valor: ");
scanf("%f", &R);
}
Eq_paral=Eq_paral+(1/R);
Eq_serie=Eq_serie+R;
}
printf("La resistencia equivalente en paralelo es %f.\n", 1/Eq_paral);
printf("La resistencia equivalente en serie es %f.\n", Eq_serie);
}
}
Calculadora básica: Pide el operador y los operandos hasta que introduce el símbolo '&'.
Solución:
/***********************/
/* Tema 4: Ejercicio 8 */
/***********************/
#include <stdio.h>
void main() {
char operacion;
float op1,op2;
do {
/* Pedir la operación */
printf("Operación: ");
fflush(stdin); /* Se borra el buffer de teclado */
scanf("%c", &operacion);
if (operacion=='+' || operacion=='-' || operacion=='*' || operacion=='/' ||
operacion=='%' || operacion=='p' || operacion=='P') {
/* Pedir los operandos, si es un operador válido */
printf("Operando 1: ");
scanf("%f", &op1);
printf("Operando 2: ");
scanf("%f", &op2);
}
switch (operacion) {
case '+': printf("Resultado: %f\n", op1+op2); break;
case '-': printf("Resultado: %f\n", op1-op2); break;
case '*': printf("Resultado: %f\n", op1*op2); break;
case '/': printf("Resultado: %f\n", op1/op2); break;
case '%': printf("Resultado: %li\n", (long int)op1 % (long int)op2); break;
case 'p':
case 'P': printf("Resultado: %f\n", op1*op2/100; break;
case '&': puts("FIN DEL PROGRAMA."); break;
default : puts("ERROR: Código de operación no válido.");
}
} while (operacion != '&')
}
Observe que el operador módulo (%) hace una conversión de ambos operandos al tipo long int, ya que dicho operador no está definido para los números reales. El operador de porcentaje (en mayúscula o minúscula) calcula el porcentaje de op1 en op2. Ejemplo: 5 P 20, es el 5% de 20, es decir, 1.
Efectuar un programa que lea dos números enteros y muestre en pantalla todos los números comprendidos entre dichos números, ambos incluidos. El programa no debe suponer que el primero será menor que el segundo, ni viceversa, pero sí que deberá tenerlo en cuenta para mostrar los números en orden creciente o decreciente según corresponda.
Modifique después el programa anterior para que los números sean mostrados por filas, de forma que cada fila tenga n números. El número de números por filas, n, será leído al principio del programa. Cada número puede ir separado del siguiente por el carácter tabulador (carácter '\t').
Solución:
/************************/
/* Tema 4: Ejercicio 10 */
/************************/
#include <stdio.h>
void main() {
int n1,n2,i,nfila,contador=0;
printf("Dame el primer número: ");
scanf("%d", &n1);
printf("Dame el segundo número: ");
scanf("%d", &n2);
printf("Dime cuántos números por fila (número de columnas): ");
scanf("%d", &nfila);
if (n1<n2) /* orden creciente */
for(i=n1;i<=n2;i++) {
printf("%d ", i);
contador++;
if (contador % nfila != 0)
printf("\t"); /* tabulador */
else
printf("\n"); /* nueva línea */
}
else /* orden decreciente */
for(i=n1;i>=n2;i--){
printf("%d ", i);
contador++;
if (contador % nfila != 0)
printf("\t");
else
printf("\n");
}
}
Escriba un programa que determine si la cadena abc aparece en una sucesión de caracteres cuyo final viene dado por un punto.
Solución:
/************************/
/* Tema 4: Ejercicio 13 */
/************************/
#include <stdio.h>
void main() {
char leido;
int Hay_abc=0; /* Esta variable tomará el valor 1 (verdadero) si se ha
encontrado la cadena abc y 0 (falso) en otro caso */
printf("Introduzca una cadena acabada en punto: ");
scanf("%c", &leido); /* se lee el primer carácter */
while (leido != '.') {
if (leido == 'a'){
scanf("%c", &leido);
if (leido == 'b') {
scanf("%c", &leido);
if (leido == 'c'){
Hay_abc=1; /* Se ha encontrado la cadena abc */
scanf("%c", &leido);
}
}
}
else
scanf("%c", &leido);
}
if (Hay_abc)
puts("La cadena abc SI está incluida en la cadena tecleada.");
else
puts("La cadena abc NO está incluida en la cadena tecleada.");
}
Observe que puede introducir varios caracteres RETURN (Intro o Enter). El programa se parará cuando encuentre el carácter punto y no cuando encuentre cualquier otro carácter.
Escribe un programa que lea un número natural N y un carácter. La salida debe ser un rombo compuesto del carácter y de la anchura que especifica el número N (diagonal horizontal). Por ejemplo, si N es 4 y el carácter es *, el rombo sería:
* * * * * * * * * * * * * * * *
Solución:
/************************/
/* Tema 4: Ejercicio 15 */
/************************/
#include <stdio.h>
void main() {
unsigned int N,fila,col;
char car;
printf("Dame la anchura del rombo: ");
scanf("%u", &N);
printf("Dame el carácter: ");
fflush(stdin);
car=getchar();
/* Dibujar el triangulo superior: */
for(fila=1;fila<=N;fila++) {
for(col=1;col<=N-fila;col++)
printf(" ");
for(col=1;col<=fila;col++)
printf("%c ",car);
printf("\n");
}
/* Dibujar el triangulo inferior: */
for(fila=1;fila<N;fila++) {
for(col=1;col<=fila;col++)
printf(" ");
for(col=1;col<=N-fila;col++)
printf("%c ",car);
printf("\n");
}
}
Observe que el triángulo inferior también podría hacerse haciendo que el bucle for tome valores decrecientemente y cambiando convenientemente los bucles internos: for(fila=N;fila>1;fila--) { ... }
Diseña y optimiza un programa que calcule números combinatorios.
Cnm = n! / (m! (n-m)!)
Un número combinatorio Cnm calcula el número de partes de m elementos que se pueden tomar de un conjunto de n elementos. Si n=m, el número es 1. Si n<m el programa deberá dar un mensaje de error ya que no se pueden tomar subconjuntos de mayor tamaño que el propio conjunto.
Solución:
/************************/
/* Tema 4: Ejercicio 18 */
/************************/
#include <stdio.h>
void main() {
int n,m,i;
long int numerador=1,denominador=1;
printf("Introduce el valor de n (número de elementos del conjunto): ");
scanf("%d", &n);
printf("Introduce el valor de m (número de elementos de los subconjuntos): ");
scanf("%d", &m);
if (n==m)
printf("El resultado es 1.\n");
else if (n<m)
printf("Error: n no puede ser menor que m.\n");
else {
/* Se calcula el numerador: */
for(i=n;i<=(n-m+1);i--)
numerador *= i;
/* Se calcula el denominador: */
for(i=2;i<=m;i++)
denominador *= i;
printf("El resultado es %ld.\n", numerador/denominador);
}
}
Calcule e imprima en pantalla los N primeros números primos, siendo N un número que se introduce por teclado. Ej: Para N=7, el programa tendría que escribir los números: 1, 2, 3, 5, 7, 11, 13.
Solución:
/************************/
/* Tema 4: Ejercicio 26 */
/************************/
#include <stdio.h>
void main() {
int cont,N,i,p;
int es_primo; /* si un número es primo se pone a 1 (verdad) */
printf("Introduce el número de primos: ");
scanf("%d", &N);
if (N>0) {
printf("\n1 "); /* se escribe el primer primo, el 1 */
cont=1; /* número de primos que tenemos */
p=2; /* siguiente número para comprobar si es primo */
while (cont!=N) {
i=p/2;
es_primo=1; /* se supone que es primo */
while (i>=2 && es_primo) {
/* si i divide a p entonces NO es primo */
if (p%i == 0)
es_primo=0;
else
i--;
}
if (es_primo) { /* Si p es primo, escribirlo y contarlo */
printf("%d ", p);
cont++;
}
p++; /* Ver si es primo el siguiente */
}
}
}
Dada una sucesión, de longitud indeterminada, de ceros y unos, construir un programa que permita calcular el tamaño de la mayor subsucesión ordenada de menor a mayor. La sucesión se lee desde el teclado, y el final viene dado por el número 2. Ejemplo: Para la siguiente sucesión el resultado es 4: 010010011010112.
Solución:
/************************/
/* Tema 4: Ejercicio 29 */
/************************/
#include <stdio.h>
void main() {
int tam=0, /* Tamaño de la subsucesión creciente actual */
max=0; /* Tamaño máximo encontrado hasta el momento actual */
char ant='0', /* Carácter anterior, inicializado al valor mínimo */
act; /* Carácter actual, el último que se ha leído */
puts("Introduce una sucesión de ceros y unos. Para terminar introduce un dos:");
act=getchar(); /* leemos cada número (0,1 o 2) como un carácter */
while (act!= '2'){
if (act>=ant)
tam++;
else
tam=1;
if (tam>max)
max=tam;
ant=act;
act=getchar(); /* leemos el siguiente carácter */
}
printf("El tamaño de la mayor subsucesión es %d.\n", max);
}
Observe que los operadores relacionales (>, >=...) también pueden utilizarse en el tipo char ya que, de hecho, lo que se almacena en ese tipo son números, siguiendo el código ASCII. El ejercicio utiliza el hecho de que el carácter '0' está antes que el carácter '1' (los caracteres de los números están en su orden en la tabla ASCII).