Ejercicios Parcial 3

EJERCICIO 3.
//a) Calcular 20 números pseudoaleatorios entre 1 y 100 mostrando cada número generado. Al final mostrar cuántos números pares se generaron.
static void AleatoriosDe1A100Pares()
{
Random Ale = new Random();
int contadorPares = 0;
Console.WriteLine("Generando 20 números pseudoaleatorios entre 1 y 100:");

for (int i = 0; i < 20; i++)
{
int numero = Ale.Next(1, 100);
Console.Write(numero + " ");
if (numero % 2 == 0)
{
contadorPares++;
}
}
Console.WriteLine();
Console.WriteLine("Cantidad de números pares generados: " + contadorPares);
}//Fin del método AleatoriosDe1A100
//b) Modificar el algoritmo para mostrar los números generados en una sola línea y separados por comas; Mostrar cuántos pares e impares se
generaron sin crear una nueva variable para contar impares.
static void AleatoriosDe1A100PareseImpares()

{
Random Ale = new Random();
int contadorImpares = 0;
Console.WriteLine("Generando 20 números pseudoaleatorios entre 1 y 100:");
for (int i = 0; i < 20; i++)

{
int numero = Ale.Next(1, 101);
Console.Write(numero + ", ");
{
contadorPares++;
}
else
{
contadorImpares++;
}
}
Console.WriteLine("Cantidad de números pares generados: " + contadorPares);
Console.WriteLine("Cantidad de números impares generados: " + contadorImpares);
}//Fin del método AleatoriosDe1A100PareseImpares
}//Fin de la clase Program
EJERCICIO 3.3
static void CalcularSumaDel1Al1000000()

{
long resultado = CalcularSuma(1, 1000000);
Console.WriteLine("La suma de números del 1 al 1,000,000 es: " + resultado);
}//Fin del método CalcularSumaDel1Al1000000
static long CalcularSuma(long inicio, long fin)

{
long suma = 0;
for (long i = inicio; i <= fin; i++)
{
suma += i;
}
return suma;
}//Fin del método CalcularSuma
EJERCICIO 3.4
internal class Program
static void Main(string[] args)
MostrarCuadrados();
Console.ReadKey();
}//Fin del método Main
static void MostrarCuadrados()

{
for (int i = 1; i <= 100; i++)
int cuadrado = i * i;
Console.WriteLine("Número: " + i + " -Su cuadrado es: " + cuadrado);
}//Fin del método MostrarCuadrados
EJERCICIO 3.9
//a) Mostrar los múltiplos positivos de 3 menores o iguales que un número entero positivo N que el usuariodigita.
static void MúltiplosDe3MenoresoIgualesaN()

{
Console.Write("Ingresa un número entero positivo: ");
int N = int.Parse(Console.ReadLine());
Console.WriteLine("Múltiplos de 3 menores o iguales que " + N + ":");

for (int i = 3; i <= N; i += 3)
{
Console.WriteLine(i);
}
}//Fin del método MúltiplosDe3MenoresoIgualesaN
//b) Realizar el mismo ejercicio utilizando una estructura repetitiva distinta del anterior.
static void MúltiplosDe3MenoresoIgualesaDigitoUsuario()

{
Console.Write("Ingresa un número entero positivo: ");
int N = int.Parse(Console.ReadLine());
Console.WriteLine("Múltiplos de 3 menores o iguales que " + N + ":");

int i = 3;
while (i <= N)
{
i += 3;
}
}//Fin del método MúltiplosDe3MenoresoIgualesaDigitoUsuario
namespace Ejercicio3_10
{
static void SucesionCrecienteNum(int m, int n)

{
/*if (m < n)
{*/
for (int i = m; i <= n; i++)
{
Console.Write(i + " ");
}
}
static void PedirNumOtraVez(int m, int n)
{
while (m == 0 || m == 1 || n == 0 || n == 1)
{
Console.WriteLine("Error: Los números deben ser diferentes de 0 y 1. Intente nuevamente.");
string[] input = Console.ReadLine().Split();
m = int.Parse(input[0]);
n = int.Parse(input[1]);
}
}//Fin del método PedirNumOtraVez
static void Oportunidades(int m, int n)
{
int intentosRestantes = 3;
while (m >= n && intentosRestantes > 0)
{
Console.WriteLine($"Error: M debe ser menor que N. Tiene {intentosRestantes} intentos restantes.");
string[] input = Console.ReadLine().Split();
m = int.Parse(input[0]);
n = int.Parse(input[1]);
intentosRestantes--;
}
}//Fin del método Oportunidades
}
{
{
{
MostrarNumPares();
Console.ReadKey();
static void MostrarNumPares()
{
int sum = 0;
for (int i = 2; i <= 2000; i++)
{
sum += i;
}
Console.WriteLine("La sumatoria de los números pares es: " + sum);
}//Fin del método MostrarNumPares
}
{
{
{
Console.WriteLine("Ingrese un número: ");
int numero = int.Parse(Console.ReadLine());
MostrarNumerosPares(numero);
Console.ReadKey();
static void MostrarNumerosPares(int numeroLimite)
{
int suma = 0;
int i = 2;
while (i <= numeroLimite)

{
suma += i;
i += 2;
}
Console.WriteLine("La sumatoria de los números pares es: " + suma);

}
}//Fin de la Clase Program
}
{
{
{
MostrarNumerosImpares();
MostrarNumerosPares();
Console.ReadKey();
static void MostrarNumerosImpares()
{
int i = 1;
Console.WriteLine("Listado de números impares desde 1 al 999:");
do
{
i += 2;
} while (i <= 999);
}
static void MostrarNumerosPares()
{
int i = 2;
Console.WriteLine("Listado de números pares desde 2 al 500:");
do
{
i += 2;
} while (i <= 500);
}
}
{
{
{
Console.WriteLine("Digite el precio de una fotocopia: ");
double precioFotocopia = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Listado de precios según el precio de fotocopias desde 1 hasta 1000:");

MostrarListadoPrecios(precioFotocopia);
Console.ReadKey();
static void MostrarListadoPrecios(double precioFotocopia)
{
for (int i = 1; i <= 1000; i++)
{
double total = i * precioFotocopia;
Console.WriteLine("Cantidad: " + i + ", Precio total: $" + total);
}
}
}
{
{
{
Console.WriteLine("Digite el precio de una fotocopia:");
double precioFotocopia = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Listado de precios para cantidades de fotocopias desde 1 hasta 1000:");

MostrarListadoPrecios(precioFotocopia);
MostrarListadoConDescuento();
Console.ReadKey();
static void MostrarListadoPrecios(double precioFotocopia)
{
for (int i = 1; i <= 1000; i++)
{
double total = i * precioFotocopia;
Console.WriteLine("Cantidad: " + i + ", Precio total: $" + total);
}
}//Fin del método MostrarListadoPrecios
static void MostrarListadoConDescuento()
{
Console.WriteLine("Listado con descuento:");
for (int i = 1; i <= 999; i++)

{
if (i % 2 != 0)
{
AplicarDescuento(i);
}
else if (i >= 2 && i <= 500)
{
AplicarDescuento(i);
}
}
}//Fin del método MostrarListadoConDescuento
static void AplicarDescuento(int cantidad)
{
double descuento;
if (cantidad >= 100 && cantidad <= 200)

{
descuento = cantidad * 0.1;
Console.WriteLine("Descuento del 10%: " + descuento);
}
else if (cantidad > 200 && cantidad <= 500)
{
}
else if (cantidad > 500)
{
}
else
{
Console.WriteLine("Sin descuento");
}
}//Fin del método AplicarDescuento
}
{
{
{
ConstruirListado();
Console.ReadKey();
public static void ConstruirListado()
{
List<int> listado = new List<int>();
for (int i = 2; i <= 1000; i += 2)

{
listado.Add(i);
}
int j = 3;
while (j <= 1000)
{
listado.Add(j);
j += 3;
}
int k = 4;
do
{
listado.Add(k);
k += 4;
} while (k <= 1000);
// Muestra el listado en la consola

foreach (int numero in listado)
{
Console.WriteLine(numero);
}
}
}
{
{
{
CalcularValoresFuncion();
Console.ReadKey();
public static void CalcularValoresFuncion()
{
for (double x = -10; x <= 10; x += 0.1)
{
if (x <= 3 || x == 5)
{
// No se puede calcular el logaritmo de números negativos o cero, ni se puede dividir entre cero
Console.WriteLine("No se puede calcular para x = " + x);
}
else
{
double resultado = Math.Pow(Math.Log(x - 3), 2) / (5 - x);
Console.WriteLine("x = " + x + ", f(x) = " + resultado);
}
}
}//Fin del método CalcularValoresFuncion
}
{
{
{
double x = 2.0;
double xFinal = 2.0;
double paso = 0.2;
Console.WriteLine("Calculando los valores de la función f(x) = x^3 - 1/x^5 + 1");

Console.WriteLine("Desde x = 2 hasta x = 2 con saltos de 0.2");
while (x <= xFinal)

{
double resultado = CalcularFuncion(x);
Console.WriteLine($"f({x}) = {resultado}");
x += paso;
}
Console.ReadKey();
static double CalcularFuncion(double x)
{
return Math.Pow(x, 3) - 1 / Math.Pow(x, 5) + 1;
}//Fin del método CalcularFuncion
}
{
{
{
int numero;
Console.WriteLine("Introduce un número:");
numero = int.Parse(Console.ReadLine());
Console.WriteLine("Tabla de multiplicar del número {0} en orden inverso:", numero);

MostrarTablaMultiplicarInversa(numero);
Console.ReadKey();
public static void MostrarTablaMultiplicarInversa(int numero)
{
for (int i = 10; i >= 1; i--)
{
int resultado = numero * i;
Console.WriteLine("{0} x {1} = {2}", numero, i, resultado);
}
}//Fin del método MostrarTablaMultiplicarInversa
}
{
{
{
MostrarTablasDeMultiplicar();
Console.ReadKey();
// Método que muestra las tablas de multiplicar del 3, 7, 9 y 12
public static void MostrarTablasDeMultiplicar()
{
MostrarTabla(3);
MostrarTabla(7);
MostrarTabla(9);
MostrarTabla(12);
}//Fin del método MostrarTablasDeMultiplicar
// Método que muestra la tabla de multiplicar de un número determinado
public static void MostrarTabla(int numero)
{
Console.WriteLine("Tabla de multiplicar del {0}:", numero);
for (int i = 1; i <= 10; i++)

{
int resultado = numero * i;
Console.WriteLine("{0} x {1} = {2}", numero, i, resultado);
}
Console.WriteLine(); // Salto de línea para separar las tablas

}//Fin del método MostrarTabla
}
EJERCICIO 3_21

{
{
TablasDeMultiplicarDePhastaQ();
Console.ReadKey();
static void TablasDeMultiplicarDePhastaQ()

{
Console.WriteLine("Ingrese el valor de P (Desde cúal tabla de multiplicar):");
int p = int.Parse(Console.ReadLine());
Console.WriteLine("Ingrese el valor de Q (Hasta cúal tabla de multiplicar):");

int q = int.Parse(Console.ReadLine());
if (p <= q)
{
for (int i = p; i <= q; i++)
{
Console.WriteLine("Tabla de multiplicar del: " + i);
Console.WriteLine("---------------------------");
for (int j = 1; j <= 10; j++)

{
int resultado = i * j;
Console.WriteLine(i + " x " + j + " = " + resultado);
}
}
}
else
{
Console.WriteLine("Error: P debe ser menor o igual que Q.");
}
}//Fin del método TablasDeMultiplicarDePhastaQ
EJERCICIO 3_22

{
{
TablasDeMultiplicarSinCondición();
Console.ReadKey();
static void TablasDeMultiplicarSinCondición()

{
Console.WriteLine("Ingrese el valor de P (Tabla de multiplicar inicial):");
int p = int.Parse(Console.ReadLine());
Console.WriteLine("Ingrese el valor de Q (Tabla de multiplicar final):");

int q = int.Parse(Console.ReadLine());
if (p <= q)
{
for (int i = p; i <= q; i++)
{
MostrarTablaMultiplicar(i);
}
}
else
{
for (int i = p; i >= q; i--)
{
MostrarTablaMultiplicar(i);
}
}
}//Fin del método TablasDeMultiplicarSinCondición
static void MostrarTablaMultiplicar(int numero)

{
Console.WriteLine("Tabla de multiplicar del: " + numero);
Console.WriteLine("---------------------------");
for (int j = 1; j <= 10; j++)

{
int resultado = numero * j;
Console.WriteLine(numero + " x " + j + " = " + resultado);
}
}//Fin del método MostrarTablaMultiplicar
EJERCICIO 3_23

{
{
Console.WriteLine("Teclea un entero positivo hasta donde se generaran los cuadrados: ");
ulong num = ulong.Parse(Console.ReadLine());
MostrarCudradosHasta(num);
Console.ReadKey();
static ulong ElevarAlCuadradro(ulong n)

{
ulong cuadrado = 0;
ulong impar;
for (ulong i = 1; i <= n; i++)
{
impar = 2 * i - 1;
cuadrado += impar;
}
return cuadrado;
}//Fin del método ElevarAlCuadradro
static void MostrarCudradosHasta (ulong n)

{
for (ulong i = 1; i <= n; i++)
{
Console.WriteLine(i + "^2 = " + ElevarAlCuadradro(i));
}
}//Fin del método MostrarCudradosHasta
EJERCICIO 3_24

{
{
CalcularFactorialCon0yNegativoTerminar();
Console.ReadKey();
static void CalcularFactorialCon0yNegativoTerminar()

{
int numero;
do
{
Console.WriteLine("Ingrese un número para calcular su factorial (presione 0 o un número negativo para salir):");
if (numero > 0)
{
long factorial = CalcularFactorial(numero);
Console.WriteLine("El factorial de " + numero + " es: " + factorial);
}
else if (numero <= 0)
{
Console.WriteLine("Fin del programa.");
}
} while (numero > 0);

}//Fin del método CalcularFactorial
static long CalcularFactorial(int numero)

{
long factorial = 1;
for (int i = 2; i <= numero; i++)

{
factorial *= i;
}
return factorial;
}
EJERCICIO 3_25

{
{
Console.WriteLine(ListaFibonacciMenoresQue(1000));
Console.ReadKey();
static ulong FibonacciNúmero(ulong posición)

{
ulong f=0, f1= 0, f2=1;
if(posición == 1)
{
f = 0;
}
else if (posición ==2)
{
f = 1;
}
else
{
for (ulong i = 3; i <= posición; i++)
{
f = f1 + f2;
f1 = f2;
f2 = f;
}
}
return f;
}//Fin del método FibonacciNúmero
static string ListaFibonacciMenoresQue(ulong n)

{
string cad = "";
ulong fibo;
for (ulong i = 1; true; i++)
{
fibo = FibonacciNúmero(i);
if (fibo <= n)
{
cad += fibo + ", ";
}
else
{
return cad;
break;
}
}
}//Fin del método ListaFibonacciMenoresQue

EJERCICIO 3_26

{
{
Primeros1000NúmerosDeFibonacci();
Console.ReadKey();
static void Primeros1000NúmerosDeFibonacci()

{
int n = 1000;
ulong a = 0;
ulong b = 1;
for (int i = 0; i <= n; i++)

{
Console.WriteLine(a);
ulong valortemporal = a;
a = b;
b = valortemporal + b;
}
}//Fin del método Primeros1000NúmerosDeFibonacci
EJERCICIO 3_27

{
{
EsPrimoOno();
Console.ReadKey();
static void EsPrimoOno()

{
Console.WriteLine("Ingrese un número entero positivo:");
ulong numero = ulong.Parse(Console.ReadLine());
bool esPrimo = EsPrimo(numero);
if (esPrimo)
{
Console.WriteLine("El número " + numero + " es primo.");
}
else
{
Console.WriteLine("El número " + numero + " no es primo.");
}
}//Fin del método EsPrimoOno
static bool EsPrimo(ulong n)
{
bool esPrimo = true;
for (ulong i = 2; i <= Math.Sqrt(n); i++)
{
if (n % i == 0)
{
esPrimo = false;
break;
}
}
return esPrimo;
}//Fin del método EsPrimo

EJERCICIO 3_28

{
{
MúltiplosDeSieteDe0a150();
Console.ReadKey();
static void MúltiplosDeSieteDe0a150()
{
Console.WriteLine("Múltiplos de siete del 0 al 150:");
for (int i = 0; i <= 150; i++)

{
if (i % 7 == 0)
{
}
}
}//Fin del método MúltiplosDeSieteDe0a150
EJERCICIO 3_29

{
{
Console.WriteLine(GenerarNumerosYsumarConLimite(1, 100,1000));
Console.ReadKey();
static string GenerarNumerosYsumarConLimite(int rangoInf, int rangoSup, ulong limitesuma)

{
Random ale = new Random(DateTime.Now.Millisecond);
string cad= " ";
ulong numero, suma = 0;
for(ulong i =1; true; i++)
{
numero = (ulong)ale.Next(rangoInf, rangoSup + 1);
if (suma + numero <= limitesuma)
{
suma += numero;
cad += numero + " ";
}
else
{
break;
}
}
return cad + " Suma = " + suma;
}//Fin del método GenerarNumerosYsumarConLimite

EJERCICIO 3_30

{
{
SumaParesMultiplicarImpares();
Console.ReadKey();
static void SumaParesMultiplicarImpares()

{
int sumaPares = 0;
int productoImpares = 1;
int ultimoPar = 0;
int ultimoImpar = 1;
while (sumaPares <= 200 && productoImpares <= 1000)

{
ultimoPar += 2;
ultimoImpar += 2;
sumaPares += ultimoPar;
productoImpares *= ultimoImpar;
}
Console.WriteLine("Último número par generado: " + ultimoPar);

Console.WriteLine("Último número impar generado: " + ultimoImpar);
Console.WriteLine("Suma de los números pares: " + sumaPares);
Console.WriteLine("Producto de los números impares: " + productoImpares);
}//Fin del método SumaParesMultiplicarImpares
3.30 Sumar los números pares (2, 4, 6, ...) y multiplicar los números impares (1, 3, 5, ...) hasta que la suma de pares sea mayor que 200 o el
producto de impares mayor que 1000. Muestre los valores de los últimos números generados, la suma y el producto obtenidos.
{
AnalizarNumeros();
Console.ReadKey();
}//Fin del mètodo Main
static void AnalizarNumeros()
{
int sumaPares = 0;
int productoImpares = 1;
int ultimoPar = 0;
int ultimoImpar = 1;
while (sumaPares <= 200 && productoImpares <= 1000)

{
if (ultimoPar % 2 == 0)
{
sumaPares += ultimoPar;
}
else
{
productoImpares *= ultimoImpar;
}
ultimoPar += 2;
ultimoImpar += 2;
}
Console.WriteLine("Último número par generado: " + (ultimoPar - 2));
Console.WriteLine("Último número impar generado: " + (ultimoImpar - 2));
Console.WriteLine("Suma de números pares: " + sumaPares);
Console.WriteLine("Producto de números impares: " + productoImpares);
}//Fin del mètodo AnalizarNumeros
3.31 Generar y mostrar números pseudoaleatorios entre 1 y 20 mostrando cada número; detener el proceso cuando salgan 3 múltiplos de 5;
Mostrar los 3 múltiplos y calcular su producto acumulado.

{
{
GenerarNumerosAleatorios();
Console.ReadKey();
static void GenerarNumerosAleatorios()

{
Random rnd = new Random();
int contadorMultiplosDe5 = 0;
int productoMultiplosDe5 = 1;
while (contadorMultiplosDe5 < 3)

{
int numeroAleatorio = rnd.Next(1, 21);
Console.WriteLine("Número generado: " + numeroAleatorio);
if (numeroAleatorio % 5 == 0)
{
contadorMultiplosDe5++;
productoMultiplosDe5 *= numeroAleatorio;
}
}
Console.WriteLine("Se han generado 3 múltiplos de 5.");
Console.WriteLine("Producto acumulado de los 3 múltiplos de 5: " + productoMultiplosDe5);
}//Fin del mètodo GenerarNumerosAleatorios
}//Fin de la clase program
3.32 a) Leer una lista de calificaciones (entre 0 y 5) y calcular el promedio, el número de aprobados (notas mayores o iguales que 3) y
reprobados (notas menores que 3); el programa terminará cuando se introduzca un número negativo.
b) Modificarlo de tal manera que se compruebe si la nota está entre 0 y 5; en el caso que no lo está volver a pedir la nota. Para terminar la
introducción de notas se pulsará 6.

{
{
Console.WriteLine(AnalizarNotas());
Console.ReadKey();
}
static string AnalizarNotas()

{
double promedio = 0, nota;
bool terminar = false;
uint contAprobados = 0, contReprobados = 0;
Console.WriteLine("Teclea la lista de notas. para terminar teclea una nota negativa");
while (terminar == false)
{
nota = double.Parse(Console.ReadLine());
if (nota >= 0)
{
promedio += nota;
if (nota >= 3) contAprobados++;
else contReprobados++;
}
else terminar = true;
}
return "promedio = " + (promedio / (contReprobados + contAprobados)) + "Aprobados " + contAprobados + " Reprobados" +
contReprobados;
}//Fin del mètodo AnalizarNotas
3.33 Introducir una lista de números enteros positivos desde el teclado conociendo que al teclear Cero termina la lista. Mostrar de la lista
los valores Máximo y el Mínimo. El número cero no cuenta como el mínimo.

{
{
MostrarMaximoYMinimoDeLista();
Console.ReadKey();
static void MostrarMaximoYMinimoDeLista()

{
Console.WriteLine("Introduce una lista de números enteros positivos (para terminar, ingresa 0):");
int numero;
int maximo = int.MinValue;
int minimo = int.MaxValue;
bool terminar = false;
while (!terminar)
{
if (numero == 0)
{
terminar = true;
}
else
{
if (numero > maximo)
{
maximo = numero;
}
if (numero < minimo)

{
minimo = numero;
}
}
}
if (minimo == int.MaxValue)
{
Console.WriteLine("No se ingresaron números válidos.");
}
else
{
Console.WriteLine("Valor Máximo: " + maximo);
Console.WriteLine("Valor Mínimo: " + minimo);
}
}//Fin del mètodo MostrarMaximoYMinimoDeLista
}//Fin de la calse program
3.34 Los términos de la serie de Fibonacci hasta que rebase un valor n (entero y positivo) leído por el teclado. En esta serie los dos
primeros números son 0 y 1, y el resto se obtiene sumando los dos anteriores: 0, 1, 1, 2,
3, 5, 8, 13, 21...

{
{
Console.WriteLine("Ingresa el valor de n:");

int n = int.Parse(Console.ReadLine());
MostrarSerieFibonacci(n);
Console.ReadKey();
static void MostrarSerieFibonacci(int n)

{
int a = 0;
int b = 1;
int c = 0;
Console.WriteLine("Serie de Fibonacci " + n + ":");

Console.Write(a + ", " + b + ", ");
while (c <= n)
{
c = a + b;
if (c <= n)
{
Console.Write(c + ", ");
}
a = b;
b = c;
}
}//Fin del mètodo MostrarSerieFibonacci
3.35 Conjetura de ULAM o Conjetura de Collatz: Empiece con cualquier número entero positivo. Si es par divídalo entre 2 y si es impar
multipliquelo por 3 y aumente 1. La conjetura dice si se comienza con cualquier número entero positivo, al aplicar el algoritmo a este
número y sucesivamente a los resultados que se vayan obteniendo siempre se llegará a 1. Construya un
algoritmo que reciba un número entero positivo, aplique sucesivamente el algoritmo, finalice cuando se obtenga 1 y muestre la sucesión de
resultados obtenidos.
Observe los tres ejemplos:
Empezando con 6, resulta la sucesión: 6, 3, 10, 5, 16, 8, 4, 2, 1.
Empezando con 11, resulta la sucesión 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1.
Empezamos con 5 la serie sería 5, 16, 8, 4, 2, 1.

{
{
Console.WriteLine("Ingresa un número entero positivo:");
MostrarSucesionCollatz(numero);
Console.ReadKey();
static void MostrarSucesionCollatz(int numero)

{
Console.Write("Sucesión de Collatz para " + numero + ": ");
Console.Write(numero + ", ");
while (numero != 1)
{
{
numero /= 2;
}
else
{
numero = numero * 3 + 1;
}
Console.Write(numero);
if (numero != 1)
{
Console.Write(", ");
}
}
}//Fin del mètodo MostrarSucesionCollatz
3.36 Calcular las siguientes series:

a) 1/1 + 1⁄2 + 1/3 + 1⁄4 + 1/5 + ... +1/n
b) Pi = 4 – 4/3 + 4/5 – 4/7 + 4/9 – 4/11 + ...
c) 1 – 1⁄2 + 1⁄4 - 1/6 + 1/8 – 1/10 + 1/12- ...
El usuario debe ingresar el número de términos con el que quiere hacer el cálculo.

{
{
Console.WriteLine("Ingresa el número de términos para las series:");
Console.WriteLine("Serie a):");
SerieA(n);
Console.WriteLine("Serie b):");
SerieB(n);
Console.WriteLine("Serie c):");
SerieC(n);
Console.ReadKey();
static void SerieA(int n)

{
double suma = 0;
for (int i = 1; i <= n; i++)
{
suma += 1.0 / i;
}
Console.WriteLine("Resultado de la serie a): " + suma);

}//fin del mètodo SerieA
static void SerieB(int n)

{
double suma = 0;
for (int i = 0; i < n; i++)

{
double termino = 4.0 / (2 * i + 1);
if (i % 2 == 0)
{
suma += termino;
}
else
{
suma -= termino;
}
}
Console.WriteLine("Resultado de la serie b): " + suma);

}//Fin del mètodo serieB
static void SerieC(int n)

{
double suma = 0;
for (int i = 1; i <= n; i++)

{
double termino = 1.0 / (2 * i);
if (i % 2 == 0)
{
suma -= termino;
}
else
{
suma += termino;
}
}
Console.WriteLine("Resultado de la serie c): " + suma);

}//Fin del mètodo SerieC
3.37 Introducir por teclado una serie de números enteros positivos y mostrar su promedio cuando se pulse la tecla “P”

{
{
CalcularPromedio();
Console.ReadKey();
}//fin del mètodo Main
static void CalcularPromedio()

{
int totalNumeros = 0;
int suma = 0;
Console.WriteLine("Ingresa una serie de números enteros positivos (para calcular el promedio, pulsa la tecla \"P\"):");
while (true)
{
string entrada = Console.ReadLine();
if (entrada.ToUpper() == "P")
{
if (totalNumeros > 0)
{
double promedio = (double)suma / totalNumeros;
Console.WriteLine("El promedio es: " + promedio);
}
else
{
Console.WriteLine("No se ingresaron números válidos.");
}
break;
}
if (int.TryParse(entrada, out int numero) && numero > 0)

{
totalNumeros++;
suma += numero;
}
else
{
Console.WriteLine("Ingresa un número entero positivo válido o presiona \"P\" para calcular el promedio.");
}
}
}//Fin del mètodo calcular promedio
3.38 Generar 100 números pseudoaleatorios entre 1 y 50 y calcular su promedio, el promedio de pares y el de impares.

{
{
CalcularPromedios();
Console.ReadKey();
static void CalcularPromedios()

{
Random rnd = new Random();
int totalNumeros = 100;
int sumaTotal = 0;
int sumaPares = 0;
int sumaImpares = 0;
int contadorImpares = 0;
for (int i = 0; i < totalNumeros; i++)

{
int numeroAleatorio = rnd.Next(1, 51);
sumaTotal += numeroAleatorio;
if (numeroAleatorio % 2 == 0)
{
sumaPares += numeroAleatorio;
contadorPares++;
}
else
{
sumaImpares += numeroAleatorio;
contadorImpares++;
}
}
double promedioTotal = (double)sumaTotal / totalNumeros;

double promedioPares = (double)sumaPares / contadorPares;
double promedioImpares = (double)sumaImpares / contadorImpares;
Console.WriteLine("Promedio general: " + promedioTotal.ToString("F2"));

Console.WriteLine("Promedio de números pares: " + promedioPares.ToString("F2"));
Console.WriteLine("Promedio de números impares: " + promedioImpares.ToString("F2"));
} //Fin del mètodo CalcularPromedios
3.39 Imprimir los números del 100 al 1 y a su lado mostrar el valor de su raíz cuadrada solamente para quienes la tengan exacta (resultado
entero).

{
{
MostrarNumerosConRaizExacta();
Console.ReadKey();
static void MostrarNumerosConRaizExacta()

{
Console.WriteLine("Números del 100 al 1 con su raíz cuadrada exacta (resultado entero):");
for (int i = 100; i >= 1; i--)

{
double raiz = Math.Sqrt(i);
int raizEntera = (int)raiz;
if (raizEntera * raizEntera == i)
{
Console.WriteLine(i + " - " + raizEntera);
}
else
{
}
}
}//Fin del mètodo MostrarNumerosConRaizExacta
3.40 Imprimir los números primos menores que 500.

{
{
Console.WriteLine("Los números primos menores que 500 son:");
MostrarNumerosPrimos();
Console.ReadKey();
static void MostrarNumerosPrimos()

{
for (int numero = 2; numero < 500; numero++)
{
if (EsPrimo(numero))
{
Console.Write(numero + " ");
}
}
}//Fin del mètodo MostrarNumerosPrimos
static bool EsPrimo(int numero)

{
if (numero < 2)
{
return false;
}
for (int i = 2; i * i <= numero; i++)

{
if (numero % i == 0)
{
return false;
}
}
return true;
}//Fin del mètodo EsPrimo
{
{
{
Console.Write("Ingrese un número N mayor o igual que 1: ");
Console.WriteLine("Las N primeras expresiones de la secuencia son:");
MostrarSecuencia(n);
Console.ReadKey();
static void MostrarSecuencia(int n)
{
int inicio = 0;
int incremento = 3;
for (int i = 1; i <= n; i++)

{
int resultado = inicio + incremento;
Console.WriteLine($"({i}) {inicio} + {incremento} = {resultado}");
inicio = resultado + 1;
incremento += 4;
}
}
}
{
{
{
Console.Write("Ingrese un número entero positivo: ");
int cantidadPrimos, cantidadCuadrados;

ContarPrimosYCuadrados(numero, out cantidadPrimos, out cantidadCuadrados);
Console.WriteLine($"Cantidad de números primos hasta {numero}: {cantidadPrimos}");

Console.WriteLine($"Cantidad de cuadrados perfectos hasta {numero}: {cantidadCuadrados}");
Console.ReadKey();
static bool EsPrimo(int num)
{
if (num <= 1)
return false;
if (num == 2)
return true;
for (int i = 2; i <= Math.Sqrt(num); i++)
{
if (num % i == 0)
return false;
}
return true;
}
static bool EsCuadradoPerfecto(int num)
{
int raizEntera = (int)Math.Sqrt(num);
return (raizEntera * raizEntera == num);
}
static void ContarPrimosYCuadrados(int numero, out int cantidadPrimos, out int cantidadCuadrados)
{
cantidadPrimos = 0;
cantidadCuadrados = 0;

{
if (EsPrimo(i))
cantidadPrimos++;
if (EsCuadradoPerfecto(i))
cantidadCuadrados++;
}
}
}
{
{
{
int numero;
Console.WriteLine("Introduce un número entero positivo:");

int contador = ContarDigitos(numero);
Console.WriteLine("El número {0} tiene {1} digitos.", numero, contador);
Console.ReadKey();
public static int ContarDigitos(int numero)
{
int contador = 0;
if (numero == 0)
{
contador = 1;
}
else
{
while (numero != 0)
{
contador++;
numero /= 10;
}
}
return contador;
}//Fin del método ContarDigitos
}
{
{
{
Console.WriteLine("a) Imprimir los cuadrados de los 25 primeros números enteros divisibles entre 7:");
ImprimirCuadradosDivisiblesEntre7();
Console.WriteLine("\nb) Verificar si un número es múltiplo de 17. Ingrese 0 para terminar.");

VerificarMultiploDe17();
Console.ReadKey();
static void ImprimirCuadradosDivisiblesEntre7()
{
int contador = 0;
int numero = 1;
while (contador < 25)

{
{
Console.WriteLine($"{numero} ^ 2 = {numero * numero}");
contador++;
}
numero++;
}
}
static void VerificarMultiploDe17()
{
while (true)
{
Console.Write("Ingrese un número (0 para terminar): ");
if (numero == 0)
{
Console.WriteLine("Programa terminado.");
break;
}
if (numero % 17 == 0)
Console.WriteLine($"{numero} es múltiplo de 17.");
else
Console.WriteLine($"{numero} no es múltiplo de 17.");
}
}
}
{
{
{
int numero;
do
{
Console.WriteLine("Ingrese un número entero de 3 dígitos (entre 1 y 999):");
}
while (numero < 1 || numero > 999);
SepararDigitos(numero, out int unidades, out int decenas, out int centenas);
Console.WriteLine("Unidades: {0}", unidades);

Console.WriteLine("Decenas: {0}", decenas);
Console.WriteLine("Centenas: {0}", centenas);
Console.ReadKey();
public static void SepararDigitos(int numero, out int unidades, out int decenas, out int centenas)
{
unidades = numero % 10;
decenas = (numero / 10) % 10;
centenas = numero / 100;
}//Fin del método SepararDigitos
}
{
{
{
RuletaParImpar();
Console.ReadKey();
static void RuletaParImpar()
{
int pares = 0;
int impares = 0;
Random random = new Random();
int numero;
do
{
numero = random.Next(0, 39);
Console.WriteLine("Número generado: {0}", numero);
{
pares++;
}
else
{
impares++;
}
}
while (numero != 0);
Console.WriteLine("Cantidad de números pares generados: {0}", pares);
Console.WriteLine("Cantidad de números impares generados: {0}", impares);
}//Fin del método RuletaParImpar
}
{
{
{
int primeraPotencia = PotenciasDeDos();
Console.WriteLine($"La primera potencia de 2 que pasa de 700 es: {primeraPotencia}");
Console.ReadKey();
static int PotenciasDeDos()
{
int potenciaActual = 1;
int exponente = 0;
while (potenciaActual <= 700)

{
Console.WriteLine("Potencia de 2: {0}", potenciaActual);
potenciaActual *= 2;
exponente++;
}
return potenciaActual;
}//Fin del método PotenciasDeDos
}
{
{
{
int num1, num2;
// Solicitar al usuario los dos números enteros positivos

Console.Write("Ingrese el primer número: ");
num1 = Convert.ToInt32(Console.ReadLine());
Console.Write("Ingrese el segundo número: ");

num2 = Convert.ToInt32(Console.ReadLine());
int resultado = AlgoritmoRuso(num1, num2);
Console.WriteLine("El resultado de la multiplicación es: {0}", resultado);
Console.ReadKey();
// Método que implementa el algoritmo ruso para la multiplicación
public static int AlgoritmoRuso(int a, int b)
{
int resultado = 0;
while (a > 0)
{
if (a % 2 != 0)
{
resultado += b;
}
a = a / 2;
b = b * 2;
}
return resultado;
}//FIn del método AlgoritmoRuso
}
3.50 De acuerdo con un principio aritmético un número es múltiplo de 3 cuando la suma de sus cifras da un múltiplo de3. Con base en este
principio decir si un número que se introduce desde el teclado es múltiplo de 3.

{
{
Console.Write("Ingresa un número entero: ");

if (EsMultiploDe3(numero))
{
Console.WriteLine($"{numero} es múltiplo de 3.");
}
else
{
Console.WriteLine($"{numero} no es múltiplo de 3.");
}
Console.ReadKey();
}//Fin del mètodo main
static bool EsMultiploDe3(int numero)
{
// Calculamos la suma de las cifras del número
int sumaCifras = 0;
int numAbsoluto = Math.Abs(numero); // Tomamos el valor absoluto para trabajar con positivos
while (numAbsoluto > 0)

{
sumaCifras += numAbsoluto % 10;
numAbsoluto /= 10;
}
// Comprobamos si la suma de las cifras es múltiplo de 3

return sumaCifras % 3 == 0;
}//Fin del mètodo EsMultiploDe
3.51 Leer un número e imprimir cuántos dígitos impares y cuántos pares tiene.

{
{
Console.WriteLine("Ingresa un número entero:");
int pares, impares;

ContarParesEImpares(numero, out pares, out impares);
Console.WriteLine("Número de dígitos pares: " + pares);

Console.WriteLine("Número de dígitos impares: " + impares);
Console.ReadKey();
static void ContarParesEImpares(int numero, out int pares, out int impares)
{
pares = 0;
impares = 0;
while (numero > 0)

{
int digito = numero % 10;
if (digito % 2 == 0)
{
pares++;
}
else
{
impares++;
}
numero /= 10;
}
}//Fin del mètodo ContarParesEImpares
3.52 Calcular el M.C.D y el M.C.M. de dos números leídos.

{
{
Console.WriteLine("Ingresa el primer número:");
int numero1 = int.Parse(Console.ReadLine());
Console.WriteLine("Ingresa el segundo número:");

int numero2 = int.Parse(Console.ReadLine());
int mcd = CalcularMCD(numero1, numero2);

int mcm = CalcularMCM(numero1, numero2);
Console.WriteLine("Máximo Común Divisor (MCD): " + mcd);

Console.WriteLine("Mínimo Común Múltiplo (MCM): " + mcm);
Console.ReadKey();
static int CalcularMCD(int a, int b)

{
while (b != 0)
{
int temp = b;
b = a % b;
a = temp;
}
return a;
}//Fin del mètodo CalcularMCD
static int CalcularMCM(int a, int b)

{
return (a / CalcularMCD(a, b)) * b;
}//Fin del mètodo CalcularMCD
3.53 Elevar un número real a una potencia entera sin usar la función respectiva.

{
{
Console.WriteLine("Ingresa el número real:");
double numeroReal = double.Parse(Console.ReadLine());
Console.WriteLine("Ingresa el exponente entero:");

int exponente = int.Parse(Console.ReadLine());
double resultado = CalcularPotencia(numeroReal, exponente);
Console.WriteLine("El resultado de " + numeroReal + " elevado a la potencia " + exponente + " es: " + resultado);
Console.ReadKey();
static double CalcularPotencia(double numero, int exponente)

{
double resultado = 1.0;
if (exponente >= 0)
{
for (int i = 0; i < exponente; i++)
{
resultado *= numero;
}
}
else
{
for (int i = 0; i < -exponente; i++)
{
resultado /= numero;
}
}
return resultado;
}//Fin del mètodo CalcularPotencia
3.54 Calcule el producto de todos los números entre 1 y un número leído por el usuario (n) e imprima el resultado.

{
{
Console.WriteLine("Ingresa un número entero:");
long producto = CalcularProducto(n);
Console.WriteLine("El producto de los números entre 1 y " + n + " es: " + producto);
Console.ReadKey();
static long CalcularProducto(int n)

{
long producto = 1;
for (int i = 1; i <= n; i++)

{
producto *= i;
}
return producto;
}//Fin del mètodo CalcularProducto
3.55 Imprimir los números del uno al cien excepto los múltiplos de 7, es decir: 1 2 3 4 5 6 8 9 10 11 12 13 15 16 17 18 19 20 22...

{
{
Console.WriteLine("Números del 1 al 100 excepto los múltiplos de 7:");

ImprimirNumerosExceptoMultiplosDe7();
Console.ReadKey();
static void ImprimirNumerosExceptoMultiplosDe7()

{
for (int i = 1; i <= 100; i++)
{
if (i % 7 != 0)
{
}
}
}//Fin del mètdo ImprimirNumerosExceptoMultiplosDe7
3.56 Leer n números enteros y calcular la suma, promedio, producto, el mayor y el menor.

{
{
Console.WriteLine("Cuantos nùmeros son? ");
uint cantidad = uint.Parse(Console.ReadLine());
Console.WriteLine(ProcesarNumeros(cantidad));
Console.ReadKey();
static string ProcesarNumeros(uint cantidadNum)

{
uint n, suma = 0, producto = 1, mayor = 0, menor = 0, i = 0;
Console.WriteLine("Teclea un nùmero entero ");
do
{
n = uint.Parse(Console.ReadLine());
suma += n;
producto *= n;
if (n > mayor) mayor = n;
else if ( n < menor) menor = n;
i++;
} while( i < cantidadNum );
return "suma = " + suma + " producto = " + producto + " Promedio = " + ((double)suma / cantidadNum) + " Mayor = " + mayor + " Menor = "
+ menor;
}//Fin del mètodo ProcesarNumeros
3.57 Leer n números e imprimir el mayor de los múltiplos de 5 leídos y el menor de los múltiplos de 3 leídos.

{
{
Console.WriteLine("Ingresa el número de elementos:");
int mayorMultiploDe5 = EncontrarMayorMultiploDe5(n);

int menorMultiploDe3 = EncontrarMenorMultiploDe3(n);
Console.WriteLine("El mayor múltiplo de 5 es: " + mayorMultiploDe5);

Console.WriteLine("El menor múltiplo de 3 es: " + menorMultiploDe3);
Console.ReadKey();
}//Fin del mètdo Main
static int EncontrarMayorMultiploDe5(int n)

{
int mayor = int.MinValue;
for (int i = 0; i < n; i++)
{
Console.WriteLine("Ingresa el número " + (i + 1) + ":");
if (numero % 5 == 0 && numero > mayor)
{
mayor = numero;
}
}
return mayor;
}//Fin del mètodo EncontrarMayorMultiploDe5
static int EncontrarMenorMultiploDe3(int n)

{
int menor = int.MaxValue;
for (int i = 0; i < n; i++)
{
Console.WriteLine("Ingresa el número " + (i + 1) + ":");
if (numero % 3 == 0 && numero < menor)
{
menor = numero;
}
}
return menor;
}//Fin del mètodo EncontrarMenorMultiploDe3
3.58 Calcular el promedio de los números múltiplos de 9 que hay de 45 a 194.

{
{
double promedio = CalcularPromedioMultiplosDe9(45, 194);
Console.WriteLine("El promedio de los múltiplos de 9 entre 45 y 194 es: " + promedio);
Console.ReadKey();
static double CalcularPromedioMultiplosDe9(int inicio, int fin)

{
int suma = 0;
int cantidadMultiplosDe9 = 0;
for (int i = inicio; i <= fin; i++)

{
if (i % 9 == 0)
{
suma += i;
cantidadMultiplosDe9++;
}
}
if (cantidadMultiplosDe9 == 0)
{
Console.WriteLine("No hay múltiplos de 9 en el rango especificado.");
return 0;
}
return (double)suma / cantidadMultiplosDe9;

}//Fin del mètodo CalcularPromedioMultiplosDe9
3.59 Calcular los cuadrados, los cubos y las raíces cuadradas de los números del 1 al 9 y presente los resultados dela
siguiente manera: 1 1 1 1 2 4 8 1.414 3 9 27 1.732 . . . . 9 81 729 2.080

{
{
Console.WriteLine("N\tCuadrado\tCubo\tRaíz cuadrada");
Console.WriteLine("---------------------------------------");
CalcularYMostrarResultados();
Console.ReadKey();
static void CalcularYMostrarResultados()

{
for (int i = 1; i <= 9; i++)
{
int cuadrado = i * i;
int cubo = i * i * i;
double raizCuadrada = Math.Sqrt(i);
Console.WriteLine($"{i}\t{cuadrado}\t\t{cubo}\t{raizCuadrada:f3}");
}
}//Fin del mètodo CalcularYMostrarResultados
3.60 Imprimir una tabla de dos columnas para la conversión entre las temperaturas en grados Fahrenheit comprendidas entre 10 oF y 200
oF, según incrementos de 15 oF y su equivalente en grados Celsius.

{
int inicioFahrenheit = 10;
int finFahrenheit = 200;
int incremento = 15;
Console.WriteLine("Tabla de conversión de Fahrenheit a Celsius:");

Console.WriteLine("------------------------------------------");
Console.WriteLine(" °F | °C ");
Console.WriteLine("---------------------");
GenerarTablaConversiónFahrenheitACelsius(inicioFahrenheit, finFahrenheit, incremento);
Console.ReadKey();

static void GenerarTablaConversiónFahrenheitACelsius(int inicioFahrenheit, int finFahrenheit, int incremento)
{
int fahrenheit = inicioFahrenheit;
while (fahrenheit <= finFahrenheit)
{
double celsius = ConvertirFahrenheitACelsius(fahrenheit);
Console.WriteLine($" {fahrenheit,4} | {celsius,7:F2}");
fahrenheit += incremento;
}
}//Fin del mètodo GenerarTablaConversiónFahrenheitACelsius
static double ConvertirFahrenheitACelsius(int fahrenheit)

{
return (fahrenheit - 32) * 5.0 / 9.0;
}//Fin del mètodo ConvertirFahrenheitACelsius
EJERCICIO 3_61
{
{
PromedioDeLosCuadrados();
Console.ReadKey();
static void PromedioDeLosCuadrados()

{
Console.WriteLine("Ingrese un número entero: ");
double sumaCuadrados = 0;
int cantidadNumeros = 0;
for (int i = 1; i <= n; i++)

{
double cuadrado = Math.Pow(i, 2);
sumaCuadrados += cuadrado;
cantidadNumeros++;
}
double promedio = sumaCuadrados / cantidadNumeros;
Console.WriteLine("El promedio de los cuadrados es: " + promedio);
}//Fin del método PromedioDeLosCuadrados
EJERCICIO 3_62

{
{
Console.WriteLine("Ingrese el valor de x:");
ulong x = ulong.Parse(Console.ReadLine());
Console.WriteLine("Ingrese el número de términos (n):");

ulong n = ulong.Parse(Console.ReadLine());
Console.WriteLine("La sumatoria de la serie A es: " + ParaNterminosSerieA(x,n));
Console.WriteLine(" ");
Console.WriteLine("La sumatoria de la serie B es: " + ParaNterminosSerieB(x, n));
Console.WriteLine("La sumatoria de la serie C es: " + ParaNterminosSerieC(x, n));
Console.WriteLine("La sumatoria de la serie D es: " + ParaNterminosSerieD(x, n));
Console.ReadKey();
static double ParaNterminosSerieA (ulong x, ulong n)

{
double sumatoria = 0;
int termino = 1;
for (ulong i = 0; i < n; i++)

{
sumatoria += termino;
termino *= 2;
}
return sumatoria;
}//Fin del método ParaNterminosSerieA
static double ParaNterminosSerieB(ulong x, ulong n)

{
int termino = 5;

{
termino *= 2;
}
return sumatoria;
}//Fin del método ParaNterminosSerieB
static double ParaNterminosSerieC(ulong x, ulong n)

{
ulong terminoBase = x - 1;

{
int exponente = (i % 2 == 0) ? 2 : 4;
int termino = (int)Math.Pow(terminoBase - (2 * i), exponente);
}
return sumatoria;
}//Fin del método ParaNterminosSerieC
static double ParaNterminosSerieD(ulong x, ulong n)

{
ulong terminoBase = x - 1;

{
double termino = Math.Pow(-1, i) * Math.Pow(terminoBase, i + 1);
}
return sumatoria;
}//Fin del método ParaNterminosSerieD
EJERCICIO 3_63

{
{
ProductoMedianteSumasSucesivas();
Console.ReadKey();
static void ProductoMedianteSumasSucesivas()

{
Console.WriteLine("Ingrese el primer número entero:");
int num1 = int.Parse(Console.ReadLine());
Console.WriteLine("Ingrese el segundo número entero:");

int num2 = int.Parse(Console.ReadLine());
int producto = 0;
for (int i = 0; i < num2; i++)

{
producto += num1;
}
Console.WriteLine("El producto de " + num1 + " y " + num2 + " es: " + producto);
}//Fin del método ProductoMedianteSumasSucesivas
EJERCICIO 3_64

{
{
Console.WriteLine(NúmerosPerfectosHasta(10000));
Console.ReadKey();
static bool EsPerfecto (ulong n)

{
ulong suma = 0;
for (ulong i = 2; i <= n / 2; i++)
if (n % i == 0) suma += i;
suma++;
if (suma == n) return true;
else return false;
}//Fin del método EsPerfecto
static string NúmerosPerfectosHasta(ulong n)

{
string cad = "";
for (ulong i = 6; true; i++)
{
if (EsPerfecto(i) == true && i <= n)
cad += i + " ";
else if (i > n)
break;
}
return cad;
}//Fin del método NúmerosPerfectosHasta

EJERCICIO 3_65

{
{
QueClaseDeNúmeroEs();
Console.ReadKey();
static void QueClaseDeNúmeroEs()

{
Console.WriteLine("Ingrese un número:");
int sumaDivisores = 0;
for (int i = 1; i < numero; i++)
{
{
sumaDivisores += i;
}
}
if (sumaDivisores == numero)
{
Console.WriteLine("El número ingresado es perfecto.");
}
else if (sumaDivisores < numero)
{
Console.WriteLine("El número ingresado es defectivo.");
}
else
{
bool semiperfecto = false;
for (int i = 1; i < numero; i++)
{
int sumaDivisoresParciales = 0;
for (int j = 1; j < numero; j++)
{
if (i % j == 0)
{
sumaDivisoresParciales += j;
}
}
if (sumaDivisoresParciales == i && sumaDivisores - i == numero)
{
semiperfecto = true;
break;
}
}
if (semiperfecto)
{
Console.WriteLine("El número ingresado es semiperfecto.");
}
else
{
Console.WriteLine("El número ingresado es abundante.");
}
}
}//Fin del método QueClaseDeNúmeroEs
EJERCICIO 3_66

{
{
NúmeroDeDíasVividosYañosBisiestos();
Console.ReadKey();
static void NúmeroDeDíasVividosYañosBisiestos()

{
Console.WriteLine("Ingrese su fecha de nacimiento:");
Console.Write("Día: ");
int diaNacimiento = int.Parse(Console.ReadLine());
Console.Write("Mes: ");
int mesNacimiento = int.Parse(Console.ReadLine());
Console.Write("Año: ");
int añoNacimiento = int.Parse(Console.ReadLine());
DateTime fechaNacimiento = new DateTime(añoNacimiento, mesNacimiento, diaNacimiento);

DateTime fechaActual = DateTime.Now;
if (fechaNacimiento > fechaActual || añoNacimiento < 0 || añoNacimiento >= 2100)

{
Console.WriteLine("La fecha de nacimiento ingresada es inválida.");
}
else
{
TimeSpan tiempoVivido = fechaActual - fechaNacimiento;
int diasVividos = tiempoVivido.Days;
int añosBisiestos = ContarAñosBisiestos(fechaNacimiento, fechaActual);
Console.WriteLine("Número de días vividos: {0}", diasVividos);

Console.WriteLine("Número de años bisiestos transcurridos: {0}", añosBisiestos);
}
}//Fin del método NúmeroDeDíasVividosYañosBisiestos
static int ContarAñosBisiestos(DateTime fechaInicio, DateTime fechaFin)

{
int contador = 0;
for (int año = fechaInicio.Year; año <= fechaFin.Year; año++)

{
if (DateTime.IsLeapYear(año))
{
contador++;
}
}
return contador;
}//Fin del método ContarAñosBisiestos

EJERCICIO 3_67

{
{
NúmeroDeDecimalesYmostrarElResultado();
Console.ReadKey();
static void NúmeroDeDecimalesYmostrarElResultado()

{
Console.WriteLine("Ingrese un número con decimales:");
string numeroStr = Console.ReadLine();
Console.WriteLine("Ingrese el número de decimales a dejar:");

int decimales = int.Parse(Console.ReadLine());
int indexPunto = numeroStr.IndexOf(".");

if (indexPunto == -1)
{
Console.WriteLine("El número ingresado no tiene decimales.");
}
else
{
int longitudCorte = indexPunto + decimales + 1;
if (longitudCorte > numeroStr.Length)
{
longitudCorte = numeroStr.Length;
}
string resultado = numeroStr.Substring(0, longitudCorte);
Console.WriteLine("El número resultante es: " + resultado);
}
}//Fin del método NúmeroDeDecimalesYmostrarElResultado

EJERCICIO 3_68

{
{
NúmeroConDecimalesYNúmerosQueDeseaRedondear();
Console.ReadKey();
static void NúmeroConDecimalesYNúmerosQueDeseaRedondear ()

{
Console.WriteLine("Ingrese un número con decimales:");
string numeroStr = Console.ReadLine();
Console.WriteLine("Ingrese el número de decimales a los que desea redondear:");

int decimales = int.Parse(Console.ReadLine());
int indexPunto = numeroStr.IndexOf(".");

if (indexPunto == -1)
{
Console.WriteLine("El número ingresado no tiene decimales.");
}
else
{
int longitudCorte = indexPunto + decimales + 1;
if (longitudCorte > numeroStr.Length)
{
longitudCorte = numeroStr.Length;
}
string subStr = numeroStr.Substring(0, longitudCorte);
string[] partes = subStr.Split(".");
if (partes.Length > 1)
{
int ultimaCifra = int.Parse(partes[1].Substring(partes[1].Length - 1));
if (ultimaCifra >= 5)
{
int cifraRedondeo = int.Parse(partes[1].Substring(0, partes[1].Length - 1)) + 1;
partes[1] = cifraRedondeo.ToString();
}
else
{
partes[1] = partes[1].Substring(0, partes[1].Length - 1);
}
}
Console.WriteLine("El número resultante es: " + partes[0] + "." + partes[1]);
}
}//Fin del método NúmeroConDecimalesYNúmerosQueDeseaRedondear
EJERCICIO 3_69

{
{
ElevarUnNúmeroXaUnaPotenciaY();
Console.ReadKey();
static void ElevarUnNúmeroXaUnaPotenciaY()

{
do
{
Console.WriteLine("Ingrese el número base (X):");
double x = double.Parse(Console.ReadLine());
Console.WriteLine("Ingrese el exponente (Y):");

int y = int.Parse(Console.ReadLine());
double resultado = Math.Pow(x, y);

Console.WriteLine("El resultado de {0} elevado a la potencia {1} es: {2}", x, y, resultado);
Console.WriteLine("¿Desea realizar el cálculo de otra potencia? (S/N)");

string respuesta = Console.ReadLine();
if (respuesta.ToUpper() != "S")
{
break;
}
} while (true);
Console.WriteLine("¡Gracias por usar la calculadora de potencias!");

}//Fin del método ElevarUnNúmeroXaUnaPotenciaY
EJERCICIO 3_70

{
{
CalcularFactorialYmostralo();
Console.ReadKey();
static void CalcularFactorialYmostralo()

{
do
{
Console.WriteLine("Ingrese un número entero:");
int factorial = CalcularFactorial(numero);

Console.WriteLine("El factorial de {0} es: {1}", numero, factorial);
Console.WriteLine("¿Desea calcular el factorial de otro número? (S/N)");

string respuesta = Console.ReadLine();
if (respuesta.ToUpper() != "S")
{
break;
}
} while (true);
Console.WriteLine("¡Gracias por usar la calculadora de factoriales!");
}//Fin del método CalcularFactorialYmostrarlo
static int CalcularFactorial(int numero)

{
if (numero == 0 || numero == 1)
{
return 1;
}
int factorial = 1;

{
factorial *= i;
}
return factorial;
}//Fin del método CalcularFactorial
{
{
{
GenerarTablasMultiplicar();
Console.ReadKey();
public static void GenerarTablasMultiplicar()
{
for (int i = 1; i <= 10; i++)
{
Console.WriteLine($"Tabla de multiplicar del {i}:");
for (int j = 1; j <= 15; j++)
{
int resultado = i * j;
Console.WriteLine($"{i} x {j} = {resultado}");
}
}
}//Fin del método GenerarTablasMultiplicar
}
{
{
{
CalculaPrimeros20Primos();
Console.ReadKey();
public static void CalculaPrimeros20Primos()
{
int contador = 0;
int num = 2;
Console.WriteLine("Los primeros 20 números primos son:");
while (contador < 20)

{
if (EsPrimo(num))
{
Console.WriteLine(num);
contador++;
}
num++;
}
}//Fin del método CalculaPrimeros20Primos
public static bool EsPrimo(int numero)
{
if (numero < 2)
return false;
for (int i = 2; i <= Math.Sqrt(numero); i++)

{
return false;
}
return true;
}
{
{
{
int inicio, final;
Console.Write("Ingrese el primer número: ");

inicio = Convert.ToInt32(Console.ReadLine());
Console.Write("Ingrese el segundo número: ");

final = Convert.ToInt32(Console.ReadLine());
Console.WriteLine($"Los números primos entre {inicio} y {final} son:");
ImprimirPrimos(inicio, final);
Console.ReadKey();
public static void ImprimirPrimos(int inicio, int final)
{
int num = inicio;
while (num <= final)

{
if (EsPrimo(num))
{
Console.Write(num + " ");
}
num++;
}
}
public static bool EsPrimo(int numero)
{
if (numero < 2)
return false;

{
return false;
}
return true;
}
}
{
{
{
Console.Write("Ingrese un número: ");
int n = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("La pirámide de números es:");
ImprimirPiramideConsecutivos(n);
Console.ReadKey();
public static void ImprimirPiramideConsecutivos(int n)
{
int num = 1;
int LongLinea = 1;
while (num <= n)

{
for (int i = 0; i < LongLinea; i++)
{
Console.Write(num + " ");
num++;
if (num > n)
break;
}
LongLinea++;
}
}
}
{
{
{
Console.WriteLine("La pirámide de dígitos es:");
ImprimirDigitosPiramide(n);
Console.ReadKey();
public static void ImprimirDigitosPiramide(int n)
{
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= i; j++)
{
Console.Write(j + " ");
}
for (int k = i - 1; k >= 1; k--)

{
Console.Write(k + " ");
}
}
}
}
{
{
{
Console.WriteLine("La pirámide de dígitos es:");
ImprimirDigitoPiramide(n);
Console.ReadKey();
public static void ImprimirDigitoPiramide(int n)
{
int num = 1;
while (num <= n)

{
int i = 1;
while (i <= num)

{
Console.Write((i + num - 1) + " ");
i++;
}
int j = num - 1;
while (j >= 1)
{
Console.Write((j + num - 1) + " ");
j--;
}
num++;
}
}
}
{
{
{
Console.WriteLine("Los rombos son:");
ImprimirRombosAncho(n);
Console.ReadKey();
public static void ImprimirRombosAncho(int n)
{
int length = 2 * n - 1;
int i = 1;
while (i <= length)
{
int j;
if (i <= n)
{
j = 1;
while (j <= i)
{
j++;
}
j = 1;
while (j <= (n - i))
{
Console.Write("* ");
j++;
}
}
else
{
j = 1;
while (j <= (length - i + 1))

{
j++;
}
j = 1;
while (j <= (i - n))

{
Console.Write("* ");
j++;
}
}
i++;
}
}
}
{
{
{
Console.Write("Introduzca un número entre 0 y 10: ");
Console.WriteLine("Los triángulos son:");
ImprimirTrianguloBaseIgual(n);
Console.ReadKey();
public static void ImprimirTrianguloBaseIgual(int n)
{
int length = 2 * n - 1;
int i = 1;
while (i <= length)

{
int j;
int conteo;
if (i <= n)
{
j = 1;
conteo = i;
}
else
{
j = 2 * n - i;
conteo = length - i + 1;
}
while (j <= length)

{
Console.Write(conteo + " ");
j++;
}
i++;
}
}
}
{
{
{
int[] numeros = LeerNumeros(10);
int sumaPrimos = CalcularSumaPrimos(numeros);
Console.WriteLine($"La suma de los números primos es: {sumaPrimos}");
Console.ReadKey();
static int[] LeerNumeros(int cantidad)
{
int[] numeros = new int[cantidad];
for (int i = 0; i < cantidad; i++)

{
Console.Write($"Ingrese el número {i + 1}: ");
numeros[i] = Convert.ToInt32(Console.ReadLine());
}
return numeros;
}//Fin del método LeerNumeros
static bool EsPrimo(int numero)
{
if (numero <= 1)
return false;

{
return false;
}
return true;
static int CalcularSumaPrimos(int[] numeros)
{
int suma = 0;
foreach (int numero in numeros)

{
if (EsPrimo(numero))
suma += numero;
}
return suma;
}//Fin del método CalcularSumaPrimos
}
{
{
{
Console.Write("Ingrese un número positivo: ");
int numero = Convert.ToInt32(Console.ReadLine());
Console.WriteLine($"Sumas consecutivas que dan {numero}:");

EncontrarSumasConsecutivas(numero);
Console.ReadKey();
static void EncontrarSumasConsecutivas(int objetivo)
{
int inicio = 1;
int fin = 2;
int suma = inicio + fin;
while (inicio < fin && fin <= objetivo)

{
if (suma < objetivo)
{
fin++;
suma += fin;
}
else if (suma > objetivo)
{
suma -= inicio;
inicio++;
}
else
{
ImprimirSumaConsecutiva(inicio, fin);
suma -= inicio;
inicio++;
}
}
}
static void ImprimirSumaConsecutiva(int inicio, int fin)
{
Console.Write(" = ");
for (int i = inicio; i < fin; i++)
{
Console.Write($"{i} + ");
}
Console.WriteLine(fin);
}
}
{
{
{
int numero = Convert.ToInt32(Console.ReadLine());
Console.WriteLine($"Factorización de {numero}:");
CalcularFactorizacion(numero);
Console.ReadKey();
static void CalcularFactorizacion(int numero)
{
int divisor = 2;
while (numero > 1)

{
if (numero % divisor == 0)
{
Console.Write($"{divisor}");
numero /= divisor;
if (numero > 1)
{
Console.Write(" * ");
}
}
else
{
divisor++;
}
}
}
}

Ejercicios Parcial 3

Cargado por

Información del documento

Título original

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

Ejercicios Parcial 3

Cargado por

Copyright:

Formatos disponibles

EJERCICIO 3.

Console.WriteLine("Generando 20 números pseudoaleatorios entre 1 y 100:");

static void AleatoriosDe1A100PareseImpares()

Console.WriteLine("Generando 20 números pseudoaleatorios entre 1 y 100:");

for (int i = 0; i < 20; i++)

static void CalcularSumaDel1Al1000000()

static long CalcularSuma(long inicio, long fin)

internal class Program

static void Main(string[] args)

}//Fin del método Main

static void MostrarCuadrados()

for (int i = 1; i <= 100; i++)

Console.WriteLine("Número: " + i + " -Su cuadrado es: " + cuadrado);

}//Fin del método MostrarCuadrados

}//Fin de la clase Program

static void MúltiplosDe3MenoresoIgualesaN()

Console.WriteLine("Múltiplos de 3 menores o iguales que " + N + ":");

static void MúltiplosDe3MenoresoIgualesaDigitoUsuario()

Console.WriteLine("Múltiplos de 3 menores o iguales que " + N + ":");

static void SucesionCrecienteNum(int m, int n)

while (i <= numeroLimite)

Console.WriteLine("La sumatoria de los números pares es: " + suma);

Console.WriteLine("Listado de números impares desde 1 al 999:");

Console.WriteLine("Listado de números pares desde 2 al 500:");

Console.WriteLine("Listado de precios según el precio de fotocopias desde 1 hasta 1000:");

Console.WriteLine("Listado de precios para cantidades de fotocopias desde 1 hasta 1000:");

for (int i = 1; i <= 999; i++)

if (cantidad >= 100 && cantidad <= 200)

for (int i = 2; i <= 1000; i += 2)

// Muestra el listado en la consola

Console.WriteLine("Calculando los valores de la función f(x) = x^3 - 1/x^5 + 1");

while (x <= xFinal)

Console.WriteLine("Tabla de multiplicar del número {0} en orden inverso:", numero);

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

Console.WriteLine(); // Salto de línea para separar las tablas

internal class Program

static void TablasDeMultiplicarDePhastaQ()

Console.WriteLine("Ingrese el valor de Q (Hasta cúal tabla de multiplicar):");

for (int j = 1; j <= 10; j++)

}//Fin del método TablasDeMultiplicarDePhastaQ

}//Fin de la clase Program

internal class Program

static void TablasDeMultiplicarSinCondición()

Console.WriteLine("Ingrese el valor de Q (Tabla de multiplicar final):");

}//Fin del método TablasDeMultiplicarSinCondición

static void MostrarTablaMultiplicar(int numero)

for (int j = 1; j <= 10; j++)

internal class Program

static ulong ElevarAlCuadradro(ulong n)

static void MostrarCudradosHasta (ulong n)

internal class Program

static void CalcularFactorialCon0yNegativoTerminar()

} while (numero > 0);

static long CalcularFactorial(int numero)

for (int i = 2; i <= numero; i++)

}//Fin de la clase Program

internal class Program

static ulong FibonacciNúmero(ulong posición)

static string ListaFibonacciMenoresQue(ulong n)

}//Fin de la clase Program

internal class Program

static void Primeros1000NúmerosDeFibonacci()

for (int i = 0; i <= n; i++)