calderilla
using [Link];
internal class Program
{
private static void Calderilla(double dinero)
{
[Link] = [Link];
double valor = dinero;
while (valor >= 2)
{
[Link]("moneda de 2€");
valor = valor - 2;
}
while (valor >= 1)
{
[Link]("moneda de 1€");
valor = valor - 1;
}
while (valor >= 0.50)
{
[Link]("moneda de 0,50 centimos");
valor = valor - 0.50;
}
while (valor >= 0.20)
{
[Link]("moneda de 0,20 centimos");
valor = valor - 0.20;
}
while (valor >= 0.10)
{
[Link]("moneda de 0,10 centimos");
valor = valor - 0.10;
}
while (valor >= 0.05)
{
[Link]("moneda de 0,05 centimos");
valor = valor - 0.05;
}
while (valor >= 0.02)
{
[Link]("moneda de 0,02 centimos");
valor = valor - 0.02;
}
while (valor >= 0.01)
{
[Link]("moneda de 0,01 centimos");
valor = valor - 0.01;
}
private static void Main(string[] args)
{
Calderilla(3.95);
}
}
Factores primos
internal class Program
{
private static void DescomponerFactoresPrimos(int n)
{
int valor = n;
int div = 2;
[Link](n + " = ");
while(valor !=1)
{
while (valor % div == 0)
{
[Link](div + " x ");
valor = valor / div;
}
div++;
}
[Link]("1");
}
private static void Main(string[] args)
{
DescomponerFactoresPrimos(100);
}
}
progresion aritmeetica
internal class Program
{
private static void Main(string[] args)
{
ProgresionAritmetica(10, 15);
}
private static void ProgresionAritmetica(int n1, int n2)
{
int i, diff = n2 - n1;
int valor = n1;
for (i = 0; i < 10; i++)
{
[Link](valor + " ");
valor = valor + diff;
}
[Link]();
}
}
cuadrado hueco estrellas
internal class Program
{
private static void Main(string[] args)
{
CuadradoHuecoEstrellitas(5);
}
private static void CuadradoHuecoEstrellitas(int tam)
{
int i, j;
for(j = 0; j < tam; j++)
{
[Link]("*");
}
[Link]();
for (i = 1; i < tam-1; i++)
{
[Link]("*");
for (j = 1; j < tam-1; j++)
{
[Link](" ");
}
[Link]("*");
}
for (j = 0; j < tam; j++)
{
[Link]("*");
}
[Link]();
}
}
internal class Program
{
private static void Main(string[] args)
{
CuadradoHuecoEstrellitas(5);
}
private static void CuadradoHuecoEstrellitas(int tam)
{
int i, j;
for(j = 0; j < tam; j++)
{
[Link]("*");
}
[Link]();
for (i = 1; i < tam-1; i++)
{
[Link]("*");
for (j = 1; j < tam-1; j++)
{
[Link](" ");
}
[Link]("*");
}
for (j = 0; j < tam; j++)
{
[Link]("*");
}
[Link]();
}
}
private static void CalendarioGrafico(int mes, int anno)
{
int diasemana = DiaSemanaFecha(1, mes, anno);
int diasMes = Diasmes2(mes, anno);
int i;
[Link](" L M X J V S D");
for (i = 1; i < diasemana; i++)
{
[Link](" ");
}
for (i = 1; i<= diasMes; i++)
{
if (i < 10)
{
[Link](" ");
}
[Link](" " + i);
diasemana += 1;
if (diasemana == 8)
{
[Link]();
diasemana = 1;
}
}
private static void DescomponerFactoresPrimos(int numero)
{
int i, factor = 2;
[Link](numero + " = ");
while (numero > 1)
{
while (numero % factor == 0)
{
[Link](factor);
numero = (numero / factor);
if (numero > 1)
{
[Link](" x ");
}
}
factor = factor + 1;
}
}
piramide pegado a la izquierda
using System;
using System;
internal class Program
{
private static void Main(string[] args)
{
// Solicitar el tamaño de la pirámide
[Link]("Introduce un número entre 3 y 20: ");
int tam = [Link]([Link]());
TrianguloEstrellitas(tam);
}
private static void TrianguloEstrellitas(int tam)
{
// Verificar que el tamaño esté entre 3 y 20
if (tam < 3 || tam > 20)
{
[Link]("ERROR");
return;
}
// Imprimir la pirámide
for (int i = 1; i <= tam; i++)
{
// Imprimir las estrellas en cada fila
for (int j = 0; j < i; j++)
{
[Link]("*");
}
// Saltar a la siguiente línea después de cada fila
[Link]();
}
}
}
piramide en el medio
using System;
internal class Program
{
private static void Main(string[] args)
{
// Solicitar el tamaño de la pirámide
[Link]("Introduce un número entre 3 y 20: ");
int tam = [Link]([Link]());
TrianguloEstrellitas(tam);
}
private static void TrianguloEstrellitas(int tam)
{
// Verificar que el tamaño esté entre 3 y 20
if (tam < 3 || tam > 20)
{
[Link]("ERROR");
return;
}
// Imprimir la pirámide
for (int i = 1; i <= tam; i++)
{
// Imprimir los espacios antes de las estrellas en cada fila
for (int j = 0; j < tam - i; j++)
{
[Link](" ");
}
// Imprimir las estrellas en cada fila
for (int j = 0; j < (2 * i - 1); j++)
{
[Link]("*");
}
// Saltar a la siguiente línea después de cada fila
[Link]();
}
}
}
de cenntigrados a fahrenheit
using System;
internal class Program
{
private static void Main(string[] args)
{
// Solicitar la temperatura en grados centígrados
[Link]("Introduce la temperatura en grados Centígrados: ");
double tempC = [Link]([Link]());
// Llamar a la función y mostrar el resultado
double tempF = CentigradosAFahrenheit(tempC);
[Link]("La temperatura en Fahrenheit es: " + tempF + "°F");
}
// Función que convierte de Centígrados a Fahrenheit
private static double CentigradosAFahrenheit(double tempC)
{
return 1.8 * tempC + 32;
}
}
de centigrados a farenheit
//using System;
//internal class Program
//{
// private static void Main(string[] args)
// {
// // Solicitar la temperatura en grados centígrados
// [Link]("Introduce la temperatura en grados Centígrados: ");
// double tempC = [Link]([Link]());
// // Llamar a la función y mostrar el resultado
// double tempF = CentigradosAFahrenheit(tempC);
// [Link]("La temperatura en Fahrenheit es: " + tempF + "°F");
// }
// // Función que convierte de Centígrados a Fahrenheit
// private static double CentigradosAFahrenheit(double tempC)
// {
// return 1.8 * tempC + 32;
// }
//}
using System;
internal class Program
{
private static void Main(string[] args)
{
// Solicitar la temperatura en grados Fahrenheit
[Link]("Introduce la temperatura en grados Fahrenheit: ");
double tempF = [Link]([Link]());
// Llamar a la función y mostrar el resultado
double tempC = FahrenheitACentigrados(tempF);
[Link]("La temperatura en Centígrados es:" + tempC + " ºC" );
}
// Función que convierte de Fahrenheit a Centígrados
private static double FahrenheitACentigrados(double tempF)
{
return (tempF - 32) / 1.8;
}
}
scribe una función EscribeSerieNumeros3 que nos pide tres números. El primero tendrá que
ser un número entre 1 y 100; si el número no es correcto, lo vuelve a pedir. El segundo
tendrá que ser un número entre 1 y 100 pero con la condición de que sea mayor que el
primero; lo volverá a pedir mientras no sea correcto. El tercero tendrá que ser un número
entre 1 y 100 con la condición de que sea mayor que el primero y menor que el segundo;
también lo volverá a pedir hasta que sea correcto. Una vez que tengamos los tres números,
nos escribirá por pantalla los números comprendidos entre el primero y el tercero y en otra
línea los números comprendidos entre el tercero y el segundo. Mejor con un ejemplo: Los
tres números son 5, 12 y 7. Nos tendrá que escribir: 5 6 7 7 8 9 10 11 12
using System;
internal class Program
{
private static void Main(string[] args)
{
// Llamamos a la función EscribeSerieNumeros3
EscribeSerieNumeros3();
}
// Función que pide los tres números y escribe las series
private static void EscribeSerieNumeros3()
{
int num1, num2, num3;
// Pedir el primer número: debe estar entre 1 y 100
do
{
[Link]("Introduce el primer número (entre 1 y 100): ");
num1 = [Link]([Link]());
} while (num1 < 1 || num1 > 100);
// Pedir el segundo número: debe ser mayor que el primero y entre 1 y 100
do
{
[Link]("Introduce el segundo número (mayor que el primero y entre 1 y 100):
");
num2 = [Link]([Link]());
} while (num2 <= num1 || num2 < 1 || num2 > 100);
// Pedir el tercer número: debe ser mayor que el primero y menor que el segundo, entre
1 y 100
do
{
[Link]("Introduce el tercer número (mayor que el primero y menor que el
segundo y entre 1 y 100): ");
num3 = [Link]([Link]());
} while (num3 <= num1 || num3 >= num2 || num3 < 1 || num3 > 100);
// Escribir los números entre el primero y el tercero
for (int i = num1; i <= num3; i++)
{
[Link](i + " ");
}
[Link](); // Salto de línea
// Escribir los números entre el tercero y el segundo
for (int i = num3; i <= num2; i++)
{
[Link](i + " ");
}
[Link](); // Salto de línea
}
}
triangulo incompleto
using System;
internal class Program
{
private static void Main(string[] args)
{
// Solicitar el tamaño de la pirámide
[Link]("Introduce un número entre 3 y 20: ");
int tam = [Link]([Link]());
TrianguloEstrellitas(tam);
}
private static void TrianguloEstrellitas(int tam)
{
// Verificar que el tamaño esté entre 3 y 20
if (tam < 3 || tam > 20)
{
[Link]("ERROR");
return;
}
// Imprimir la pirámide
for (int i = 0; i < tam; i++)
{
// Imprimir los espacios antes de la estrella
for (int j = 0; j < tam - i - 1; j++)
{
[Link](" ");
}
// Imprimir las estrellas
for (int j = 0; j < 2 * i + 1; j++)
{
if (i == 0 || i == tam - 1 || j == 0 || j == 2 * i) // Bordes de la pirámide
[Link]("*");
else
[Link](" ");
}
// Saltar a la siguiente línea
[Link]();
}
}
}
devuelve maximo, minimo, y medio
internal class Program
{
private static void Main(string[] args)
{
// Ejemplo de uso de las funciones
int a = 8, b = 100, c = -2;
// Llamadas a las funciones
[Link]($"El máximo de ({a}, {b}, {c}) es: {Maximo(a, b, c)}");
[Link]($"El mínimo de ({a}, {b}, {c}) es: {Minimo(a, b, c)}");
[Link]($"El medio de ({a}, {b}, {c}) es: {Medio(a, b, c)}");
}
// Función que devuelve el máximo de tres números
private static int Maximo(int a, int b, int c)
{
int max = a; // Suponemos inicialmente que 'a' es el máximo
if (b > max) // Si 'b' es mayor que el actual 'max', entonces 'b' es el máximo
{
max = b;
}
if (c > max) // Si 'c' es mayor que el actual 'max', entonces 'c' es el máximo
{
max = c;
}
return max; // Devolvemos el máximo
}
// Función que devuelve el mínimo de tres números
private static int Minimo(int a, int b, int c)
{
int min = a; // Suponemos inicialmente que 'a' es el mínimo
if (b < min) // Si 'b' es menor que el actual 'min', entonces 'b' es el mínimo
{
min = b;
}
if (c < min) // Si 'c' es menor que el actual 'min', entonces 'c' es el mínimo
{
min = c;
}
return min; // Devolvemos el mínimo
}
// Función que devuelve el número del medio de los tres
private static int Medio(int a, int b, int c)
{
// Para obtener el número del medio, sumamos los tres y restamos el máximo y el
mínimo
return a + b + c - Maximo(a, b, c) - Minimo(a, b, c);
}
}
romboide
internal class Program
{
private static void Main(string[] args)
{
// Llamamos a la función Romboide con los valores de altura y longitud
Romboide(20, 14); // Ejemplo con altura 5 y longitud 7
[Link](); // Dejar una línea en blanco entre ejemplos
Romboide(3, 20); // Ejemplo con altura 3 y longitud 10
}
// Función que pinta un romboide con la altura y longitud proporcionadas
private static void Romboide(int altura, int longitud)
{
// Recorremos las filas (pisos) del romboide
for (int i = 0; i < altura; i++)
{
// Imprimir los espacios en blanco al principio de cada fila
// Los espacios dependen de la fila en la que estamos (i)
for (int j = 0; j < altura - i - 1; j++)
{
[Link](" ");
}
// Imprimir los asteriscos
for (int j = 0; j < longitud; j++)
{
[Link]("*");
}
// Al terminar de imprimir los asteriscos, saltamos a la siguiente línea
[Link]();
}
}
}
nota final
using System;
class Program
{
static void Main(string[] args)
{
// Llamamos a la función para calcular la nota final
CalculaNotaFinal();
}
// Función que calcula la nota final
private static void CalculaNotaFinal()
{
double nota;
int suspensos = 0;
double sumaNotas = 0;
// Pedir y procesar las 7 notas
for (int i = 1; i <= 7; i++)
{
// Pedir la nota para el examen i
nota = PedirNota(i);
// Sumar la nota a la total
sumaNotas += nota;
// Contar si la nota es menor a 5 (suspenso)
if (nota < 5)
{
suspensos++;
}
}
// Calcular la media de las notas
double media = sumaNotas / 7;
// Mostrar la media antes de ajustar
[Link]($"Media antes de ajustar: {media:F2}");
// Si hay 2 o más suspensos, la nota final no puede superar 4
if (suspensos >= 2)
{
media = [Link](media, 4); // La media no debe superar 4
}
// Mostrar la nota final
[Link]($"La nota final es: {media:F2}");
// Mantener la consola abierta para ver los resultados
[Link]();
}
// Función para pedir una nota válida
private static double PedirNota(int examen)
{
double nota = 0; // Inicializamos la variable nota con un valor predeterminado
bool notaValida = false;
// Pedir la nota hasta que sea válida
while (!notaValida)
{
[Link]($"Introduce la nota del examen {examen} (entre 0 y 10):");
string input = [Link]();
// Validar que la nota esté entre 0 y 10
if ([Link](input, out nota) && nota >= 0 && nota <= 10)
{
notaValida = true;
}
else
{
[Link]("Nota no válida. Debe estar entre 0 y 10.");
}
}
return nota;
}
}
lista cuadrado perfecto
class Program
{
static void Main(string[] args)
{
// Llamamos a la función ListaCuadradosPerfectos con un ejemplo
ListaCuadradosPerfectos(0, 20); // Ejemplo con rango de 10 a 20
}
// Función que devuelve true si un número es un cuadrado perfecto
private static bool CuadradoPerfecto(int numero)
{
if (numero < 0)
{
return false; // Los cuadrados perfectos son números no negativos
}
double raiz = [Link](numero); // Calculamos la raíz cuadrada del número
int raizEntera = (int)raiz; // Convertimos la raíz a entero truncando el valor decimal
// Verificamos si la raíz elevada al cuadrado es igual al número original
return raizEntera * raizEntera == numero;
}
// Función que escribe todos los cuadrados perfectos entre dos números
private static void ListaCuadradosPerfectos(int min, int max)
{
// Iteramos por todos los números en el rango [min, max]
for (int i = min; i <= max; i++)
{
// Si el número es un cuadrado perfecto, lo imprimimos
if (CuadradoPerfecto(i))
{
[Link](i);
}
}
}
}
fecha
using System;
class Program
{
static void Main(string[] args)
{
// Ejemplo de prueba
[Link](FechaCorrecta(31, 4, 2020)); // False
[Link](FechaCorrecta(29, 2, 2020)); // True (2020 es bisiesto)
[Link](FechaCorrecta(31, 12, 2021)); // True
[Link](FechaCorrecta(31, 2, 2021)); // False
}
// Función que verifica si la fecha es correcta
private static bool FechaCorrecta(int dia, int mes, int año)
{
// Verificar que el año esté en el rango válido
if (año < 1980 || año > 2100)
{
return false;
}
// Verificar que el mes esté en el rango válido
if (mes < 1 || mes > 12)
{
return false;
}
// Verificar que el día sea válido para el mes y año
int maxDias = DiasMaximosEnMes(mes, año);
if (dia < 1 || dia > maxDias)
{
return false;
}
// Si todas las comprobaciones son correctas, la fecha es válida
return true;
}
// Función que devuelve el número máximo de días para un mes dado un año
private static int DiasMaximosEnMes(int mes, int año)
{
// Definir los días máximos de cada mes
switch (mes)
{
case 1: // Enero
case 3: // Marzo
case 5: // Mayo
case 7: // Julio
case 8: // Agosto
case 10: // Octubre
case 12: // Diciembre
return 31;
case 4: // Abril
case 6: // Junio
case 9: // Septiembre
case 11: // Noviembre
return 30;
case 2: // Febrero
// Verificar si es un año bisiesto
if (EsBisiesto(año))
{
return 29; // Año bisiesto
}
else
{
return 28; // Año no bisiesto
}
default:
return 0; // Este caso no debería ocurrir ya que el mes está validado
previamente
}
}
// Función que determina si un año es bisiesto
private static bool EsBisiesto(int año)
{
// Un año es bisiesto si es divisible por 4, pero no por 100, o si es divisible por
400
if ((año % 4 == 0 && año % 100 != 0) || (año % 400 == 0))
{
return true;
}
return false;
}
}
ayuda gpt
Para estar bien preparado para un examen de funciones en C#, basándome en los
ejemplos de ejercicios que me has enviado, hay varios conceptos clave que necesitas
dominar. Te proporcionaré una lista de los temas y habilidades que debes conocer y
entender profundamente para abordar correctamente este tipo de ejercicios.
1. Definición y Declaración de Funciones
● Sintaxis básica: Saber cómo definir una función en C#, incluyendo:
○ Tipo de retorno (void, int, double, bool, etc.).
○ Nombre de la función.
○ Parámetros de entrada (si los hay).
○ Valor de retorno (si la función no es void).
Ejemplo:
csharp
Copiar código
private static int Sumar(int a, int b)
{
return a + b;
}
2. Parámetros de las Funciones
● Paso de parámetros por valor: La forma más común, donde los valores se
copian a la función.
● Paso de parámetros por referencia (ref y out): Cuando una función necesita
modificar los valores originales de los parámetros pasados.
○ ref: Se usa cuando el parámetro se pasa ya inicializado.
○ out: Se usa cuando la función necesita devolver un valor a través del
parámetro.
Ejemplo:
csharp
Copiar código
private static void Incrementar(ref int a)
{
a++;
}
3. Tipos de Retorno
● Saber qué tipo de datos puede devolver una función: int, double, bool,
string, etc.
● Retorno de valores: Cómo devolver valores desde una función (usando
return).
● Funciones que no devuelven valores: Funciones void, que no necesitan
devolver nada.
Ejemplo:
csharp
Copiar código
private static bool EsPar(int numero)
{
return numero % 2 == 0;
}
4. Estructuras de Control dentro de Funciones
● Condicionales (if, else, switch): Usar correctamente estructuras de control
dentro de las funciones.
● Bucles (for, while, foreach): Iterar dentro de las funciones, por ejemplo,
para recorrer rangos o listas.
Ejemplo:
csharp
Copiar código
private static void ImprimirPares(int max)
{
for (int i = 1; i <= max; i++)
{
if (i % 2 == 0)
{
[Link](i);
}
}
}
5. Funciones Matemáticas y Lógicas
● Operaciones matemáticas básicas: Uso de operaciones como suma, resta,
multiplicación, división, módulo.
● Funciones de la clase Math: Métodos como [Link](), [Link](),
[Link](), [Link](), etc.
● Operadores lógicos y de comparación: Uso de operadores como ==, !=, >, <,
&&, ||.
Ejemplo:
csharp
Copiar código
private static bool EsCuadradoPerfecto(int numero)
{
double raiz = [Link](numero);
return raiz == [Link](raiz);
}
6. Validación de Datos
● Verificación de entrada de usuario: Saber cómo validar datos de entrada
dentro de las funciones, como asegurarse de que un número esté dentro de un
rango específico.
● Uso de TryParse para convertir entradas de texto a números.
Ejemplo:
csharp
Copiar código
private static double PedirNota()
{
double nota;
while (true)
{
[Link]("Introduce una nota entre 0 y 10: ");
if ([Link]([Link](), out nota) && nota >=
0 && nota <= 10)
{
return nota;
}
else
{
[Link]("Nota no válida. Inténtalo de
nuevo.");
}
}
}
●
7. Uso de Arrays y Colecciones (Opcional, dependiendo del examen)
● Trabajar con arrays: Declarar y manipular arrays, por ejemplo, encontrar el
máximo o mínimo de un conjunto de números.
Ejemplo:
csharp
Copiar código
private static int Maximo(int[] numeros)
{
int max = numeros[0];
for (int i = 1; i < [Link]; i++)
{
if (numeros[i] > max)
{
max = numeros[i];
}
}
return max;
}
8. Funciones Recursivas (Avanzado, si es necesario)
● Recursión: Saber cuándo y cómo usar funciones recursivas. Esto puede ser
útil para problemas como la secuencia de Fibonacci o la búsqueda de
elementos en estructuras de datos.
Ejemplo:
csharp
Copiar código
private static int Factorial(int n)
{
if (n == 0)
return 1;
return n * Factorial(n - 1);
}
9. Manejo de Excepciones
● Try-Catch: Saber cómo manejar excepciones dentro de las funciones,
especialmente cuando el código puede generar errores de ejecución (por
ejemplo, dividir por cero).
Ejemplo:
csharp
Copiar código
private static void Dividir(int a, int b)
{
try
{
int resultado = a / b;
[Link]($"Resultado: {resultado}");
}
catch (DivideByZeroException)
{
[Link]("Error: División por cero.");
}
}
10. Documentación y Buenas Prácticas
● Comentarios en el código: Aunque no es estrictamente necesario para un
examen, comentar correctamente las funciones ayuda a entender lo que está
haciendo el código.
● Nombres descriptivos: Usar nombres significativos para las funciones y los
parámetros para que el código sea más fácil de entender.
11. Ejercicios típicos que podrían aparecer en el examen
● Validación de fechas (como el ejercicio de FechaCorrecta).
● Cálculo de promedios y manejo de condiciones especiales (como los
exámenes de notas).
● Trabajar con funciones matemáticas (por ejemplo, cuadrado perfecto, factorial,
operaciones).
● Creación de funciones que resuelvan problemas lógicos (por ejemplo,
determinar el máximo, mínimo o medio de tres números).
● Uso de bucles para iterar sobre rangos o colecciones (por ejemplo, imprimir
números entre dos valores).
Recomendaciones para prepararte:
1. Practica con ejercicios: Resuelve tantos ejercicios como puedas. Intenta
hacerlos de manera que no solo sigas un paso a paso, sino que entiendas
cómo se construyen las funciones.
2. Lee y comprende los ejemplos: Los ejercicios que me diste son un buen punto
de partida. Trata de entender la lógica detrás de cada uno y cómo se
implementan las funciones.
3. Haz que tu código sea claro y eficiente: Durante el examen, asegúrate de que
tu código esté bien estructurado, que las funciones tengan nombres
significativos y que sea fácil de entender.
4. Practica con validaciones de entrada: Muchos de los ejercicios incluyen
validaciones de entrada, como verificar si una fecha es válida o si un número
está dentro de un rango. Practica esto para estar seguro de que puedes
implementar controles de errores de forma efectiva.
Con estos conocimientos y habilidades, estarás bien preparado para un examen
sobre funciones en C#. ¡Buena suerte!
Si tu maestro te permite llevar ayudas al examen, ¡es una excelente oportunidad para
estar bien preparado! Aquí tienes algunas ideas útiles para lo que puedes llevar:
1. Hoja de Apuntes
Prepara una hoja con lo más esencial, como:
● Sintaxis básica:
○ Estructura de un programa en C#.
○ Ejemplo de declaración de variables (int, string, double, etc.).
○ Uso de operadores aritméticos, lógicos y de comparación.
● Estructuras de control:
○ Ejemplo de if, else if, else.
○ Ejemplo de switch.
○ Bucles: for, while y do while.
● Métodos:
○ Cómo declarar y llamar un método.
○ Ejemplo de paso de parámetros por valor y por referencia (ref, out).
● Manipulación de cadenas (string):
○ Métodos comunes: .Substring(), .Contains(), .IndexOf(),
.Split().
● Arreglos y Listas:
○ Ejemplo de declaración e inicialización de arreglos y listas.
○ Métodos comunes para listas: .Add(), .Remove(), .Count().
2. Código de Ejemplo
● Es útil tener fragmentos de código que puedas adaptar a diferentes problemas:
○ Función para leer datos desde la consola ([Link]()).
○ Ejemplo de validación de datos (verificar si es un número, por ejemplo).
○ Ejemplo de manejo de excepciones (try-catch).
○ Ejemplo de métodos recursivos.
3. Tabla de Tipos de Datos y Conversión
● Puedes incluir una tabla con los principales tipos de datos (int, double,
float, string, bool).
● Ejemplo de conversión de tipos ([Link](), Convert.ToInt32(),
ToString()).
4. Diagrama de Flujo
Si tu examen incluye problemas que requieren lógica de programación, un pequeño
diagrama de flujo puede ayudarte a planificar tu solución antes de escribir el código.
5. Guía de Errores Comunes
● Errores de sintaxis: uso incorrecto de punto y coma, llaves o paréntesis.
● Null Reference Exception: intentar acceder a un objeto nulo.
● Out of Range: acceso a un índice fuera de los límites de un arreglo o lista.
6. Material Digital (Si Permite Computadora)
Si puedes usar tu computadora o tablet:
● Ten abierta la documentación oficial de C# en Microsoft (offline).
● Ten a mano un editor de texto sencillo como Notepad o VS Code para escribir
código rápido y hacer pruebas.
Ejemplo de Hoja de Apuntes Resumida
csharp
Copiar código
// Declaración de variables
int num = 10;
string mensaje = "Hola Mundo";
// Estructura if-else
if (num > 0) {
[Link]("Número positivo");
} else {
[Link]("Número negativo");
}
// Bucle for
for (int i = 0; i < 5; i++) {
[Link](i);
}
// Método de suma
int Sumar(int a, int b) {
return a + b;
}
// Llamada al método
int resultado = Sumar(3, 4);
[Link]($"Resultado: {resultado}");
🚀
Con esta hoja de ayuda estarás bien preparado y tendrás a la mano lo que necesitas
para resolver la mayoría de los problemas. ¡Buena suerte en tu examen!
rango descende
class Program
static void Main(string[] args)
// Llamamos a la función para escribir el rango descendente
EscribeRangoDescendente();
// Función que pide los tres números y escribe el rango descendente
private static void EscribeRangoDescendente()
int primero = PedirNumero(1, 100); // Pedir primer número (entre 1 y 100)
int segundo = PedirNumeroMayor(primero, 1, 100); // Pedir segundo número
(mayor que el primero)
int tercero = PedirNumeroMayorQueElSegundo(segundo, 1, 100); // Pedir tercer
número (mayor que el segundo)
// Imprimir los números en orden descendente
for (int i = tercero; i >= segundo; i--)
[Link](i + " ");
[Link](); // Para mover a la siguiente línea al finalizar
}
private static int PedirNumero(int min, int max)
int numero;
bool numeroValido = false;
do
[Link]($"Introduce un número entre {min} y {max}: ");
numero = [Link]([Link]());
if (numero >= min && numero <= max)
numeroValido = true;
else
[Link]($"El número debe estar entre {min} y {max}. Inténtalo de
nuevo.");
} while (!numeroValido);
return numero;
private static int PedirNumeroMayor(int anterior, int min, int max)
{
int numero;
bool numeroValido = false;
do
[Link]($"Introduce un número mayor que {anterior} y entre {min} y
{max}: ");
numero = [Link]([Link]());
if (numero > anterior && numero >= min && numero <= max)
numeroValido = true;
else
[Link]($"El número debe ser mayor que {anterior} y estar entre
{min} y {max}. Inténtalo de nuevo.");
} while (!numeroValido);
return numero;
private static int PedirNumeroMayorQueElSegundo(int segundo, int min, int max)
int numero;
bool numeroValido = false;
do
{
[Link]($"Introduce un número mayor que {segundo} y entre {min} y
{max}: ");
numero = [Link]([Link]());
if (numero > segundo && numero >= min && numero <= max)
numeroValido = true;
else
[Link]($"El número debe ser mayor que {segundo} y estar entre
{min} y {max}. Inténtalo de nuevo.");
} while (!numeroValido);
return numero;
