Ejercicios de C# resueltos para principiantes: 10 ejercicios de menos a más (con clases, List y LINQ)

Aquí tienes diez ejercicios de C# resueltos para principiantes, ordenados de menos a más difíciles: condicionales, bucles, validación de datos, cadenas, arrays, métodos con out, matrices, una clase con propiedades, Dictionary y una gestión de alumnos con List y LINQ. Cada uno tiene el enunciado, la solución completa, por qué está hecha así y una variación para practicar por tu cuenta.
Son los ejercicios que más se repiten cuando Programación se da en C# en primero de DAM o DAW, en la universidad y en los primeros pasos con Unity. Si vienes de Java, tienes también una tabla con las diferencias que más se notan, y al final cinco preguntas de "¿qué imprime?" con las trampas típicas de C#.
Cómo usar estos ejercicios
Leer una solución y entenderla no es lo mismo que saber escribirla. Para que te sirvan:
- Lee el enunciado y tápate la solución. Escribe primero los pasos en castellano, como comentarios.
- Intenta resolverlo al menos 15 minutos. Si te atascas, mira solo la parte donde te has atascado y sigue tú.
- Haz la variación. Si te sale sin mirar nada, el concepto está aprendido.
Qué necesitas. Visual Studio Community en Windows, o VS Code con la extensión C# Dev Kit en Mac y Linux. Si vas a instalar .NET ahora, coge .NET 10, que es la versión con soporte largo (LTS). Todo el código de esta página funciona desde .NET 6.
Sobre el Main. Desde .NET 6, Visual Studio crea los proyectos de consola sin class Program ni static void Main: el código se escribe directamente en Program.cs. Se llaman instrucciones de nivel superior y es lo que usan las soluciones de abajo. Si tu profesor quiere el Main de siempre, mete el código dentro así:
namespace Ejercicios;
class Program
{
static void Main(string[] args)
{
// Aquí va el código del ejercicio
}
// Aquí van los métodos del ejercicio, con static
}
Las clases como CuentaBancaria o Alumno van fuera de Program, o en su propio fichero. Al crear el proyecto, Visual Studio también tiene una casilla, "No usar instrucciones de nivel superior", que te genera esta estructura.
| Nº | Ejercicio | Qué practicas |
|---|---|---|
| 1 | Calificación a partir de la nota | Console.ReadLine(), double.TryParse, if/else if |
| 2 | Números primos hasta N | for, bucles anidados, break |
| 3 | Adivina el número | while, Random, validar la entrada |
| 4 | Palíndromos y vocales | Recorrer cadenas, char, tildes |
| 5 | Máximo, mínimo y media de un array | Arrays, acumuladores, división entera |
| 6 | Validar una contraseña | Métodos, return, parámetros out |
| 7 | Sumas de filas y columnas | Matrices int[,], GetLength |
| 8 | Cuenta bancaria | Clases, propiedades, decimal, excepciones |
| 9 | Contar palabras de un texto | Dictionary, Split, TryGetValue |
| 10 | Notas de una clase | List<T>, LINQ, RemoveAll |
Si vienes de Java: lo que cambia en C#
En algunos institutos se aprende Java en primero y C# aparece en segundo, en Desarrollo de Interfaces o en Programación de Servicios y Procesos. Los dos lenguajes se parecen mucho, y por eso mismo cuesta ver las diferencias. Estas son las que más fallos dan:
| En Java | En C# | Cuidado con |
|---|---|---|
System.out.println(x) |
Console.WriteLine(x) |
Console.Write(x) no salta de línea |
Scanner y sc.nextInt() |
int.Parse(Console.ReadLine()) |
ReadLine() siempre devuelve texto |
boolean, String |
bool, string |
En C# bool imprime True y False, con mayúscula |
s1.equals(s2) |
s1 == s2 |
En C# == compara el contenido de las cadenas |
ArrayList<Integer> |
List<int> |
C# admite tipos primitivos en las listas |
HashMap<String, Integer> |
Dictionary<string, int> |
Leer una clave que no existe lanza una excepción |
getNombre() y setNombre() |
Propiedad Nombre { get; set; } |
Se usa como un atributo: a.Nombre = "Ana" |
extends e implements |
: en los dos casos |
class Perro : Animal, IComparable |
| Todos los métodos se pueden sobrescribir | Solo los marcados con virtual |
Sin virtual en la base, override no compila |
.stream().filter(...) |
LINQ: .Where(...) |
No se ejecuta hasta que recorres el resultado |
int[][] |
int[,] (rectangular) o int[][] (escalonada) |
Se recorren distinto |
Métodos en camelCase |
Métodos en PascalCase |
CalcularMedia(), no calcularMedia() |
Si tu duda es de lógica y no de sintaxis, tienes ejercicios equivalentes en ejercicios de Java resueltos para 1º de DAM y DAW.
Ejercicio 1: calificación a partir de la nota
Enunciado. Pide al usuario una nota entre 0 y 10 (puede tener decimales) y muestra su calificación: Suspenso (menos de 5), Aprobado (5 a menos de 7), Notable (7 a menos de 9) o Sobresaliente (9 o más). Si lo que escribe no es un número o está fuera de rango, muestra un aviso.
using System.Globalization;
Console.Write("Introduce la nota: ");
string texto = Console.ReadLine() ?? "";
texto = texto.Replace(',', '.');
if (!double.TryParse(texto, NumberStyles.Float, CultureInfo.InvariantCulture, out double nota))
{
Console.WriteLine("Eso no es un número");
}
else if (nota < 0 || nota > 10)
{
Console.WriteLine("La nota debe estar entre 0 y 10");
}
else if (nota < 5)
{
Console.WriteLine("Suspenso");
}
else if (nota < 7)
{
Console.WriteLine("Aprobado");
}
else if (nota < 9)
{
Console.WriteLine("Notable");
}
else
{
Console.WriteLine("Sobresaliente");
}
Por qué está hecho así:
Console.ReadLine()devuelvestring?: puede devolvernullsi la entrada se cierra. El?? ""lo cambia por una cadena vacía y evita el aviso del compilador.TryParseno lanza una excepción si el usuario escribe "hola". Devuelvefalsey te deja avisar.double.Parseharía que el programa se cerrara con unFormatException.- La trampa de la coma.
double.Parseydouble.TryParsesin más parámetros usan el idioma de tu Windows. En un Windows en español,double.Parse("6.5")devuelve 65, porque el punto es el separador de miles. En uno en inglés pasa lo contrario con"6,5". Cambiar la coma por un punto y leer conCultureInfo.InvariantCulturehace que el programa funcione igual en cualquier ordenador. - Los
else ifvan en orden y solo se ejecuta el primero que se cumple. Por eso en el denota < 7no hace falta comprobarnota >= 5: si has llegado ahí, ya lo sabes.
Variación: pide tres notas (teoría 40 %, práctica 40 %, actitud 20 %), calcula la media ponderada y muestra la calificación. Si alguna parte es menor que 4, la calificación es Suspenso aunque la media pase de 5.
Ejercicio 2: números primos hasta N
Enunciado. Pide un número entero n y muestra todos los números primos entre 2 y n. Un número es primo si solo es divisible entre 1 y él mismo.
Console.Write("¿Hasta qué número? ");
int n = int.Parse(Console.ReadLine() ?? "0");
for (int numero = 2; numero <= n; numero++)
{
bool esPrimo = true;
for (int divisor = 2; divisor * divisor <= numero; divisor++)
{
if (numero % divisor == 0)
{
esPrimo = false;
break;
}
}
if (esPrimo)
{
Console.Write(numero + " ");
}
}
Console.WriteLine();
Con n = 30 imprime 2 3 5 7 11 13 17 19 23 29.
Por qué está hecho así:
esPrimose pone atruedentro del bucle de fuera. Si lo declaras antes del bucle, en cuanto encuentra el 4 se queda enfalsepara siempre y no vuelve a imprimir nada.breaksolo sale del bucle de dentro, que es lo que queremos: deja de probar divisores y pasa al siguiente número.divisor * divisor <= numeroes lo mismo que probar hasta la raíz cuadrada. Si un número tiene un divisor mayor que su raíz, también tiene uno menor, así que no hace falta seguir. Condivisor < numerotambién funciona, pero hace muchas más vueltas.
Variación: saca la comprobación a un método static bool EsPrimo(int numero) y úsalo para mostrar los primeros 20 primos, en lugar de los primos hasta N.
Ejercicio 3: adivina el número
Enunciado. El programa piensa un número aleatorio entre 1 y 100. El usuario intenta adivinarlo y el programa le dice "más alto" o "más bajo" hasta que acierte. Al final, muestra cuántos intentos ha necesitado. Si el usuario escribe algo que no es un número, no cuenta como intento.
int secreto = Random.Shared.Next(1, 101);
int intentos = 0;
bool acertado = false;
while (!acertado)
{
Console.Write("Adivina el número (1-100): ");
if (!int.TryParse(Console.ReadLine(), out int numero))
{
Console.WriteLine("Eso no es un número entero, prueba otra vez.");
continue;
}
intentos++;
if (numero < secreto)
{
Console.WriteLine("Más alto");
}
else if (numero > secreto)
{
Console.WriteLine("Más bajo");
}
else
{
acertado = true;
}
}
Console.WriteLine($"¡Correcto! Era el {secreto}. Lo has adivinado en {intentos} intentos.");
Por qué está hecho así:
Next(1, 101)devuelve un número entre 1 y 100: el segundo valor no se incluye. Es el error más típico de este ejercicio.Random.Sharedexiste desde .NET 6. En versiones antiguas o en .NET Framework, crea unRandomuna sola vez (var azar = new Random();) y usaazar.Next(1, 101). No lo crees dentro del bucle.continuevuelve al principio del bucle sin sumar el intento, porqueintentos++está después de la validación.$"...{secreto}..."es una cadena interpolada. Es más legible que encadenar con+, y es lo que vas a ver en casi todo el código actual de C#.
Variación: limita el juego a 7 intentos. Si el usuario escribe un número fuera de 1-100, avísale y no se lo cuentes como intento.
Ejercicio 4: palíndromos y vocales
Enunciado. Pide una frase y di cuántas vocales tiene y si es un palíndromo, es decir, si se lee igual al derecho que al revés sin contar espacios, signos, mayúsculas ni tildes.
Console.Write("Escribe una frase: ");
string frase = (Console.ReadLine() ?? "").ToLower()
.Replace('á', 'a').Replace('é', 'e').Replace('í', 'i')
.Replace('ó', 'o').Replace('ú', 'u').Replace('ü', 'u');
string limpia = "";
int vocales = 0;
foreach (char c in frase)
{
if (char.IsLetterOrDigit(c))
{
limpia += c;
}
if ("aeiou".Contains(c))
{
vocales++;
}
}
bool esPalindromo = true;
for (int i = 0; i < limpia.Length / 2; i++)
{
if (limpia[i] != limpia[limpia.Length - 1 - i])
{
esPalindromo = false;
break;
}
}
Console.WriteLine($"Vocales: {vocales}");
Console.WriteLine(esPalindromo ? "Es un palíndromo" : "No es un palíndromo");
Con "Dábale arroz a la zorra el abad" imprime Vocales: 12 y Es un palíndromo.
Por qué está hecho así:
- Las tildes importan. Sin los
Replace, laáde "Dábale" no es igual a laade "abad" y el programa diría que no es un palíndromo. Pruébalo quitándolos. - Las cadenas en C# no se pueden modificar.
ToLower()yReplace()no cambian la cadena original: devuelven una nueva, y por eso se guarda el resultado enfrase. limpia[i]devuelve unchar, que va entre comillas simples ('a'). Las comillas dobles son parastring. Comparar uncharcon"a"no compila.- El bucle solo llega a la mitad: compara el primer carácter con el último, el segundo con el penúltimo, y para en cuanto encuentra una pareja distinta.
limpia += ccrea una cadena nueva en cada vuelta. Para una frase da igual. Para textos largos se usaStringBuilder.
Variación: cuenta también las consonantes y di qué vocal aparece más veces.
Ejercicio 5: máximo, mínimo y media de un array
Enunciado. Pregunta cuántos números va a introducir el usuario, guárdalos en un array y muestra el máximo, el mínimo y la media con dos decimales. Hazlo recorriendo el array, sin usar LINQ ni Max().
Console.Write("¿Cuántos números vas a introducir? ");
int cantidad = int.Parse(Console.ReadLine() ?? "0");
if (cantidad <= 0)
{
Console.WriteLine("Tiene que haber al menos un número");
return;
}
int[] numeros = new int[cantidad];
for (int i = 0; i < numeros.Length; i++)
{
Console.Write($"Número {i + 1}: ");
numeros[i] = int.Parse(Console.ReadLine() ?? "0");
}
int maximo = numeros[0];
int minimo = numeros[0];
int suma = 0;
foreach (int n in numeros)
{
if (n > maximo) maximo = n;
if (n < minimo) minimo = n;
suma += n;
}
double media = (double)suma / numeros.Length;
Console.WriteLine($"Máximo: {maximo}");
Console.WriteLine($"Mínimo: {minimo}");
Console.WriteLine($"Media: {media:F2}");
Por qué está hecho así:
maximoyminimoempiezan con el primer elemento, no con 0. Si empiezas el máximo en 0 y todos los números son negativos, el programa dirá que el máximo es 0, que ni siquiera está en el array.(double)suma / numeros.Lengthconvierte antes de dividir. Si escribessuma / numeros.Length, los dos soninty C# hace división entera: 7 / 2 da 3, no 3,5. Y(double)(suma / numeros.Length)tampoco sirve, porque convierte cuando la división entera ya está hecha.{media:F2}muestra dos decimales. En un Windows en español sale con coma (3,50), y en uno en inglés con punto.- Con
foreachpuedes leer los elementos, pero no cambiarlos. Para modificar el array necesitas elforcon índice. returnen un programa sinMaintermina el programa.
Variación: muestra también en qué posición está el máximo y cuántos números están por encima de la media.
Ejercicio 6: validar una contraseña con un método
Enunciado. Escribe un método que reciba una contraseña y diga si es válida: al menos 8 caracteres, al menos una mayúscula y al menos un número. Si no es válida, el método tiene que decir también el motivo.
Console.Write("Contraseña: ");
string clave = Console.ReadLine() ?? "";
if (EsValida(clave, out string motivo))
{
Console.WriteLine("Contraseña válida");
}
else
{
Console.WriteLine($"No es válida: {motivo}");
}
static bool EsValida(string clave, out string motivo)
{
if (clave.Length < 8)
{
motivo = "debe tener al menos 8 caracteres";
return false;
}
bool tieneMayuscula = false;
bool tieneNumero = false;
foreach (char c in clave)
{
if (char.IsUpper(c)) tieneMayuscula = true;
if (char.IsDigit(c)) tieneNumero = true;
}
if (!tieneMayuscula)
{
motivo = "le falta una letra mayúscula";
return false;
}
if (!tieneNumero)
{
motivo = "le falta un número";
return false;
}
motivo = "";
return true;
}
Por qué está hecho así:
- El método devuelve un
booly además "devuelve" el motivo por un parámetroout. Es el mismo mecanismo que usaint.TryParse(texto, out int numero). Cuando entiendes este ejercicio, entiendesTryParse. - Un parámetro
outtiene que recibir un valor antes de cadareturn. Si te olvidas en un camino, el código no compila (error CS0177). Por eso está elmotivo = ""del final. - El método no escribe nada en la consola: solo decide. El
Console.WriteLineestá fuera. Así puedes reutilizarlo en un formulario o probarlo con pruebas unitarias sin tocarlo. char.IsUpperychar.IsDigitya contemplan casos como la Ñ. Es mejor que comparar a mano conc >= 'A' && c <= 'Z'.- En un programa sin
Main, los métodos se suelen poner debajo del código que los usa. Se pueden llamar aunque estén declarados más abajo.
Variación: añade la regla "al menos un símbolo" (!char.IsLetterOrDigit(c)) y cambia el método para que devuelva una List<string> con todos los fallos, no solo el primero.
Ejercicio 7: sumas de filas y columnas de una matriz
Enunciado. Dada una matriz de enteros, muéstrala en forma de tabla con la suma de cada fila a la derecha y la suma de cada columna debajo.
int[,] matriz =
{
{ 3, 8, 1, 4 },
{ 5, 2, 7, 6 },
{ 9, 0, 2, 3 }
};
int filas = matriz.GetLength(0);
int columnas = matriz.GetLength(1);
int[] sumaColumnas = new int[columnas];
for (int f = 0; f < filas; f++)
{
int sumaFila = 0;
for (int c = 0; c < columnas; c++)
{
Console.Write($"{matriz[f, c],4}");
sumaFila += matriz[f, c];
sumaColumnas[c] += matriz[f, c];
}
Console.WriteLine($" | {sumaFila,4}");
}
Console.WriteLine(new string('-', columnas * 4 + 7));
foreach (int suma in sumaColumnas)
{
Console.Write($"{suma,4}");
}
Console.WriteLine();
Salida:
3 8 1 4 | 16
5 2 7 6 | 20
9 0 2 3 | 14
-----------------------
17 10 10 13
Por qué está hecho así:
int[,]es una matriz rectangular: todas las filas tienen las mismas columnas y se accede conmatriz[f, c]. Si vienes de Java, allí escribiríasmatriz[f][c].GetLength(0)da el número de filas yGetLength(1)el de columnas.matriz.Lengthda el total de elementos (aquí, 12). UsarLengthen el bucle de filas es un fallo muy habitual que acaba enIndexOutOfRangeException.- Las sumas de las columnas se van acumulando en un array en la misma pasada, así no hay que recorrer la matriz dos veces.
{valor,4}alinea a la derecha en 4 caracteres. Por eso la tabla sale cuadrada.- C# también tiene matrices escalonadas (
int[][]), donde cada fila puede tener un tamaño distinto. Se accede conm[f][c]y el tamaño de cada fila esm[f].Length.
Variación: con una matriz cuadrada, calcula la suma de la diagonal principal y de la secundaria, y di si la matriz es simétrica.
Ejercicio 8: una clase CuentaBancaria
Enunciado. Crea una clase CuentaBancaria con titular y saldo. Tiene que permitir ingresar y retirar dinero, sin cantidades negativas y sin retirar más de lo que hay. El saldo no se puede modificar desde fuera de la clase.
var cuenta = new CuentaBancaria("Lucía", 100m);
cuenta.Ingresar(50m);
try
{
cuenta.Retirar(500m);
}
catch (InvalidOperationException ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
Console.WriteLine(cuenta);
class CuentaBancaria
{
public string Titular { get; }
public decimal Saldo { get; private set; }
public CuentaBancaria(string titular, decimal saldoInicial)
{
if (saldoInicial < 0)
{
throw new ArgumentException("El saldo inicial no puede ser negativo");
}
Titular = titular;
Saldo = saldoInicial;
}
public void Ingresar(decimal cantidad)
{
if (cantidad <= 0)
{
throw new ArgumentException("La cantidad tiene que ser positiva");
}
Saldo += cantidad;
}
public void Retirar(decimal cantidad)
{
if (cantidad <= 0)
{
throw new ArgumentException("La cantidad tiene que ser positiva");
}
if (cantidad > Saldo)
{
throw new InvalidOperationException("Saldo insuficiente");
}
Saldo -= cantidad;
}
public override string ToString()
{
return $"{Titular}: {Saldo:C}";
}
}
Imprime Error: Saldo insuficiente y después Lucía: 150,00 € (en un Windows en inglés, $150.00).
Por qué está hecho así:
Saldo { get; private set; }es una propiedad: desde fuera se puede leer (cuenta.Saldo), pero solo la propia clase la puede cambiar. Es lo que en Java harías con un atributo privado y ungetSaldo()sinsetSaldo().Titular { get; }no tieneset, así que solo se puede asignar en el constructor. Después ya no cambia.- El dinero va en
decimal, no endouble.doubleguarda los números en binario y no representa exactamente cantidades como 0,1, así que tarde o temprano aparecen céntimos de más o de menos. Lamde100mindica que el número esdecimal. - La clase lanza una excepción cuando algo no es válido, en lugar de escribir un mensaje por consola. La clase no sabe si la usa un programa de consola o un formulario. Quien la usa decide qué hacer con el error en el
catch. override ToString()define cómo se muestra el objeto. Por esoConsole.WriteLine(cuenta)imprime algo legible y noCuentaBancaria.- En un programa sin
Main, las clases van después de todo el código suelto. Si pones la clase arriba, no compila.
Si la orientación a objetos todavía se te resiste, tienes la base con un ejemplo paso a paso en programación orientada a objetos explicada.
Variación: crea una clase CuentaAhorro que herede de CuentaBancaria (class CuentaAhorro : CuentaBancaria) y cobre una comisión de 1 € por cada retirada. Para poder sobrescribir Retirar, tendrás que marcarlo como virtual en la clase base.
Ejercicio 9: contar palabras de un texto
Enunciado. Dado un texto, cuenta cuántas veces aparece cada palabra sin distinguir mayúsculas y muestra el resultado ordenado de la más repetida a la menos. Si dos palabras se repiten lo mismo, en orden alfabético.
string texto = "El que lee mucho y anda mucho, ve mucho y sabe mucho";
char[] separadores = { ' ', ',', '.', ';', ':', '¿', '?', '¡', '!' };
string[] palabras = texto.ToLower().Split(separadores, StringSplitOptions.RemoveEmptyEntries);
var conteo = new Dictionary<string, int>();
foreach (string palabra in palabras)
{
if (conteo.TryGetValue(palabra, out int veces))
{
conteo[palabra] = veces + 1;
}
else
{
conteo[palabra] = 1;
}
}
foreach (var par in conteo.OrderByDescending(p => p.Value).ThenBy(p => p.Key))
{
Console.WriteLine($"{par.Key}: {par.Value}");
}
Salida:
mucho: 4
y: 2
anda: 1
el: 1
lee: 1
que: 1
sabe: 1
ve: 1
Por qué está hecho así:
RemoveEmptyEntrieshace falta porque detrás demucho,viene un espacio. Al cortar por los dos, queda una cadena vacía entre ellos que, sin esta opción, contaría como palabra.ToLower()va antes de cortar para que "El" y "el" sean la misma clave.- Leer una clave que no existe con
conteo[palabra]lanzaKeyNotFoundException. Escribir sí se puede: si la clave no existe, se crea.TryGetValuecomprueba y lee a la vez, sin buscar dos veces. OrderByDescendingyThenByson de LINQ, que tienes en el ejercicio 10. Aquí ordenan por número de veces y, si empatan, por la palabra.
Variación: lee el texto de un fichero con File.ReadAllText("texto.txt") y muestra solo las cinco palabras más repetidas que tengan más de tres letras.
Ejercicio 10: notas de una clase con List y LINQ
Enunciado. Con una lista de alumnos (nombre y nota), muestra los aprobados de mayor a menor nota, la media de la clase, el alumno con la mejor nota, si alguien ha sacado un 10 y la nota de un alumno buscado por nombre. Al final, borra de la lista a los suspensos.
var alumnos = new List<Alumno>
{
new Alumno("Ana", 7.5),
new Alumno("Bruno", 4.2),
new Alumno("Carla", 9.1),
new Alumno("David", 5.0),
new Alumno("Elena", 3.8)
};
// 1. Aprobados, de mayor a menor nota
var aprobados = alumnos
.Where(a => a.Nota >= 5)
.OrderByDescending(a => a.Nota)
.ToList();
Console.WriteLine("Aprobados:");
foreach (var a in aprobados)
{
Console.WriteLine($" {a.Nombre} ({a.Nota:F1})");
}
// 2. Media de la clase
double media = alumnos.Average(a => a.Nota);
Console.WriteLine($"Media de la clase: {media:F2}");
// 3. Mejor nota
Alumno mejor = alumnos.OrderByDescending(a => a.Nota).First();
Console.WriteLine($"Mejor nota: {mejor.Nombre}");
// 4. ¿Alguien ha sacado un 10?
bool hayDiez = alumnos.Any(a => a.Nota == 10);
Console.WriteLine(hayDiez ? "Hay al menos un 10" : "Nadie ha sacado un 10");
// 5. Buscar por nombre
Alumno? buscado = alumnos.FirstOrDefault(a => a.Nombre == "David");
if (buscado != null)
{
Console.WriteLine($"{buscado.Nombre} tiene un {buscado.Nota:F1}");
}
else
{
Console.WriteLine("No existe ese alumno");
}
// 6. Borrar a los suspensos
int borrados = alumnos.RemoveAll(a => a.Nota < 5);
Console.WriteLine($"Se han borrado {borrados} alumnos. Quedan {alumnos.Count}.");
class Alumno
{
public string Nombre { get; }
public double Nota { get; set; }
public Alumno(string nombre, double nota)
{
Nombre = nombre;
Nota = nota;
}
}
Salida en un Windows en español:
Aprobados:
Carla (9,1)
Ana (7,5)
David (5,0)
Media de la clase: 5,92
Mejor nota: Carla
Nadie ha sacado un 10
David tiene un 5,0
Se han borrado 2 alumnos. Quedan 3.
Por qué está hecho así:
a => a.Nota >= 5es una lambda: una función pequeña que recibe un alumno (a) y devuelve si cumple la condición. Todo LINQ funciona pasando lambdas.WhereyOrderByDescendingno ejecutan nada hasta que recorres el resultado. El.ToList()final ejecuta la consulta y guarda una lista con los resultados de ese momento.FirstOrDefaultdevuelvenullsi no encuentra a nadie. Por esobuscadoesAlumno?y se comprueba antes de usarlo. ConFirst(), si no hubiera nadie, el programa lanzaría una excepción. En el punto 3First()es seguro porque la lista no está vacía.RemoveAllno es de LINQ: es un método deList<T>que borra de la propia lista y devuelve cuántos ha borrado. LINQ nunca modifica la colección original.Where(a => a.Nota >= 5)te da una lista nueva y deja la original igual.- Desde .NET 6 tienes
MaxBy(a => a.Nota), que encuentra al mejor alumno sin ordenar toda la lista.
¿Y si en el examen no te dejan usar LINQ? Pasa en muchos institutos en primero. Aprende también la versión con bucles. La media, por ejemplo:
double suma = 0;
foreach (var a in alumnos)
{
suma += a.Nota;
}
double mediaSinLinq = suma / alumnos.Count;
Si sabes escribir cada consulta de las dos formas, LINQ deja de ser magia: es un bucle que ya está escrito.
Variación: convierte el ejercicio en un programa con menú (do-while y switch): 1. Añadir alumno, 2. Listar, 3. Buscar, 4. Borrar suspensos, 5. Estadísticas, 0. Salir. Es el formato de examen más habitual en primero.
Cinco preguntas de "¿qué imprime?" que caen siempre
Intenta responder sin ejecutar el código. Las respuestas están debajo de cada una.
1. División entera
int a = 7, b = 2;
Console.WriteLine(a / b);
Console.WriteLine((double)a / b);
Console.WriteLine(a / b * 1.0);
Imprime 3, 3,5 (o 3.5 en un Windows en inglés) y 3. Entre dos int, / es división entera. En la tercera línea, a / b se calcula primero y ya vale 3, así que multiplicar por 1.0 llega tarde.
2. Las cadenas no cambian
string nombre = "csharp";
nombre.ToUpper();
Console.WriteLine(nombre);
Imprime csharp. ToUpper() devuelve una cadena nueva y aquí no se guarda. Lo correcto es nombre = nombre.ToUpper();.
3. Arrays y variables
int[] a = { 1, 2, 3 };
int[] b = a;
b[0] = 99;
int x = 5;
int y = x;
y = 10;
Console.WriteLine($"{a[0]} {x}");
Imprime 99 5. Un array es un tipo por referencia: b = a no copia el array, hace que las dos variables apunten al mismo. Un int es un tipo por valor: y = x copia el número. Para copiar un array, int[] b = (int[])a.Clone();.
4. Comparar cadenas con ==
string s1 = "hola";
string s2 = "HOLA".ToLower();
Console.WriteLine(s1 == s2);
Imprime True, con mayúscula. En C#, == entre cadenas compara el contenido. En Java el mismo código daría false, porque allí == compara si son el mismo objeto. Es de las primeras cosas que hay que desaprender al pasar de Java a C#.
5. Sumar y concatenar
Console.WriteLine(1 + 2 + "3" + 4 + 5);
Imprime 3345. Se evalúa de izquierda a derecha: 1 + 2 es 3. Al llegar a "3" el resultado pasa a ser texto ("33"), y a partir de ahí cada + concatena: "334", "3345".
Si has fallado alguna, no la memorices. Ejecútala en Visual Studio paso a paso: pon un punto de interrupción con F9, avanza línea a línea con F10 y mira cómo cambian las variables en la ventana Variables locales. Tienes la técnica completa en cómo depurar código paso a paso.
Cómo practicar para que se quede
Escribe los pasos antes del código. Si no sabes explicar en castellano cómo resolverías el problema con papel y boli, el problema no es C#. Tres o cuatro comentarios con los pasos son la mitad del ejercicio.
Cambia el enunciado. Cuando te salga un ejercicio, haz la variación y después inventa otra. En el examen no te van a poner el mismo enunciado, te van a poner uno parecido.
Practica sin ayudas si tu examen es sin ayudas. Visual Studio completa mucho código solo, y GitHub Copilot todavía más. Si el examen es en papel o en un ordenador sin internet, desactívalo cuando practiques. Tienes cómo usar la IA para aprender sin depender de ella en aprender a programar con ChatGPT, y cómo organizarte el día del examen en cómo preparar un examen práctico de programación.
No te saltes niveles. Si el ejercicio 8 se te atraganta, vuelve al 5 y al 6. Las clases, los diccionarios y LINQ se construyen sobre los bucles y los métodos. Si los bucles cojean, todo lo demás cojea.
Cuándo pedir ayuda
Vas bien si resuelves los diez ejercicios sin mirar la solución y sabes explicar por qué está cada línea. Merece la pena pedir ayuda cuando:
- Entiendes las soluciones al leerlas, pero delante de un enunciado nuevo te quedas en blanco.
- Llevas horas con un error de Visual Studio y no sabes ni qué buscar.
- Tu curso ya va por interfaces gráficas, bases de datos o LINQ y tú todavía dudas con las clases.
- Tienes un examen o una recuperación cerca y no sabes qué priorizar.
En nuestras clases particulares de C# online trabajamos justo esto: con tus enunciados, tus prácticas y tus exámenes de otros años. Escribes tú el código y el profesor te guía hasta que te sale solo. Si estudias un ciclo o una carrera, lo adaptamos al temario de DAM y DAW o de la universidad. Son clases uno a uno por videollamada a 25 € la hora, sin matrícula ni permanencia.
Preguntas frecuentes
¿Por dónde empiezo a hacer ejercicios de C# si no sé nada?
Por ejercicios de pedir datos y mostrar resultados con condicionales, como el ejercicio 1. Después bucles, cadenas y arrays, luego métodos, y al final clases, colecciones y LINQ. Si todavía no tienes claro qué es una variable o un bucle, empieza por la ruta de cómo aprender programación desde cero.
¿Es mejor aprender C# o Java?
Para aprender a programar dan prácticamente igual: la orientación a objetos, los bucles y las colecciones funcionan igual en los dos. Elige el que te pidan en tu curso. En la mayoría de ciclos de DAM y DAW es Java. C# se usa más en aplicaciones de escritorio para Windows, en empresas que trabajan con .NET y en videojuegos con Unity. Si sabes uno, pasar al otro lleva pocas semanas.
¿Qué programa uso para hacer los ejercicios de C#?
En Windows, Visual Studio Community, que es gratuito para estudiantes y uso personal. En Mac o Linux, VS Code con la extensión C# Dev Kit, o JetBrains Rider. Para probar algo rápido sin instalar nada sirve un compilador online como .NET Fiddle, pero acostúmbrate a trabajar con proyectos en tu ordenador.
¿Qué versión de .NET tengo que instalar?
Si no te piden una concreta, .NET 10. Es la versión LTS (con soporte largo) y tiene soporte hasta noviembre de 2028. Todo el código de esta página funciona desde .NET 6. Si tu instituto usa .NET Framework 4.x, que todavía aparece en algunos proyectos de Windows Forms, el C# es una versión anterior: tendrás que meter el código en static void Main, añadir los using arriba, quitar el ? de string? y Alumno? y cambiar Random.Shared por new Random().
¿Qué es LINQ y cuándo lo puedo usar?
LINQ es la forma de C# de hacer consultas sobre colecciones (filtrar, ordenar, contar, agrupar) con métodos como Where, OrderBy o Average. Ahorra mucho código, pero esconde los bucles. Si tu profesor no lo ha explicado o el examen pide recorrer las colecciones a mano, no lo uses. Y aunque te dejen, aprende primero la versión con bucles.
¿Estos ejercicios sirven para Unity o para Windows Forms?
Sí, para la parte del lenguaje. En Unity y en Windows Forms el código está repartido en métodos que se ejecutan con eventos (Update() o el clic de un botón), pero dentro de cada método hay variables, condicionales, bucles, listas y clases, lo mismo que aquí. Si estás con interfaces en DAM, tienes las ideas clave del módulo en Desarrollo de Interfaces en DAM.
Documentación oficial
Comprobada en noviembre de 2026.
- Instrucciones de nivel superior: programas sin método Main (Microsoft Learn).
- Double.TryParse y el formato según la referencia cultural (Microsoft Learn).
- Tipos numéricos de punto flotante: float, double y decimal (Microsoft Learn).
- Matrices multidimensionales en C# (Microsoft Learn).
- Dictionary.TryGetValue (Microsoft Learn).
- Introducción a LINQ en C# (Microsoft Learn).
- Directiva de soporte de .NET: versiones LTS y STS (Microsoft).