Volver al blog

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

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:

  1. Lee el enunciado y tápate la solución. Escribe primero los pasos en castellano, como comentarios.
  2. Intenta resolverlo al menos 15 minutos. Si te atascas, mira solo la parte donde te has atascado y sigue tú.
  3. 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() devuelve string?: puede devolver null si la entrada se cierra. El ?? "" lo cambia por una cadena vacía y evita el aviso del compilador.
  • TryParse no lanza una excepción si el usuario escribe "hola". Devuelve false y te deja avisar. double.Parse haría que el programa se cerrara con un FormatException.
  • La trampa de la coma. double.Parse y double.TryParse sin 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 con CultureInfo.InvariantCulture hace que el programa funcione igual en cualquier ordenador.
  • Los else if van en orden y solo se ejecuta el primero que se cumple. Por eso en el de nota < 7 no hace falta comprobar nota >= 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í:

  • esPrimo se pone a true dentro del bucle de fuera. Si lo declaras antes del bucle, en cuanto encuentra el 4 se queda en false para siempre y no vuelve a imprimir nada.
  • break solo sale del bucle de dentro, que es lo que queremos: deja de probar divisores y pasa al siguiente número.
  • divisor * divisor <= numero es 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. Con divisor < numero tambié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.Shared existe desde .NET 6. En versiones antiguas o en .NET Framework, crea un Random una sola vez (var azar = new Random();) y usa azar.Next(1, 101). No lo crees dentro del bucle.
  • continue vuelve al principio del bucle sin sumar el intento, porque intentos++ 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 la a de "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() y Replace() no cambian la cadena original: devuelven una nueva, y por eso se guarda el resultado en frase.
  • limpia[i] devuelve un char, que va entre comillas simples ('a'). Las comillas dobles son para string. Comparar un char con "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 += c crea una cadena nueva en cada vuelta. Para una frase da igual. Para textos largos se usa StringBuilder.

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í:

  • maximo y minimo empiezan 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.Length convierte antes de dividir. Si escribes suma / numeros.Length, los dos son int y 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 foreach puedes leer los elementos, pero no cambiarlos. Para modificar el array necesitas el for con índice.
  • return en un programa sin Main termina 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 bool y además "devuelve" el motivo por un parámetro out. Es el mismo mecanismo que usa int.TryParse(texto, out int numero). Cuando entiendes este ejercicio, entiendes TryParse.
  • Un parámetro out tiene que recibir un valor antes de cada return. Si te olvidas en un camino, el código no compila (error CS0177). Por eso está el motivo = "" del final.
  • El método no escribe nada en la consola: solo decide. El Console.WriteLine está fuera. Así puedes reutilizarlo en un formulario o probarlo con pruebas unitarias sin tocarlo.
  • char.IsUpper y char.IsDigit ya contemplan casos como la Ñ. Es mejor que comparar a mano con c >= '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 con matriz[f, c]. Si vienes de Java, allí escribirías matriz[f][c].
  • GetLength(0) da el número de filas y GetLength(1) el de columnas. matriz.Length da el total de elementos (aquí, 12). Usar Length en el bucle de filas es un fallo muy habitual que acaba en IndexOutOfRangeException.
  • 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 con m[f][c] y el tamaño de cada fila es m[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 un getSaldo() sin setSaldo().
  • Titular { get; } no tiene set, así que solo se puede asignar en el constructor. Después ya no cambia.
  • El dinero va en decimal, no en double. double guarda 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. La m de 100m indica que el número es decimal.
  • 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 eso Console.WriteLine(cuenta) imprime algo legible y no CuentaBancaria.
  • 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í:

  • RemoveEmptyEntries hace falta porque detrás de mucho, 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] lanza KeyNotFoundException. Escribir sí se puede: si la clave no existe, se crea. TryGetValue comprueba y lee a la vez, sin buscar dos veces.
  • OrderByDescending y ThenBy son 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 >= 5 es una lambda: una función pequeña que recibe un alumno (a) y devuelve si cumple la condición. Todo LINQ funciona pasando lambdas.
  • Where y OrderByDescending no ejecutan nada hasta que recorres el resultado. El .ToList() final ejecuta la consulta y guarda una lista con los resultados de ese momento.
  • FirstOrDefault devuelve null si no encuentra a nadie. Por eso buscado es Alumno? y se comprueba antes de usarlo. Con First(), si no hubiera nadie, el programa lanzaría una excepción. En el punto 3 First() es seguro porque la lista no está vacía.
  • RemoveAll no es de LINQ: es un método de List<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.

WhatsApp