{

Retos

de

Programación

}

Roadmap

2024

Mini

Ejercicios

Proyectos

{

Retos

de

Programación

roadmap

}

by mouredev

# Ruta de estudio con ejercicios para aprender cualquier lenguaje

23/12/2024

## Último ejercicio publicado en la ruta de estudio

#50 planificador de objetivos de año nuevo

## Una guía que te ayuda a mejorar.

Sigue la ruta de estudio para aprender los fundamentos del lenguaje de programación que quieras desde su base, de manera práctica, paso a paso y en comunidad.

Cada semana se propondrá y explicará un nuevo ejercicio que te servirá para mejorar tu lógica de programación mientras estudias todas las características del lenguaje.

## Roadmap

## 52

Lenguajes

python (3672)

javascript (1755)

java (910)

typescript (477)

c# (340)

## 8812

Contribuciones

#00 (1504)

#01 (910)

#02 (675)

#03 (481)

#04 (398)

## 1392

Usuarios

#1 miguelex (221)

#2 kenysdev (204)

#3 eulogioep (153)

#4 hectorio23 (150)

#5 hozlucas28 (140)

    /*
     * Se publicará una vez finalizada la corrección en directo del ejercicio.
     */

    /*
     * EJERCICIO:
     * El nuevo año está a punto de comenzar...
     * ¡Voy a ayudarte a planificar tus propósitos de nuevo año!
     *
     * Programa un gestor de objetivos con las siguientes características:
     * - Permite añadir objetivos (máximo 10)
     * - Calcular el plan detallado
     * - Guardar la planificación
     *
     * Cada entrada de un objetivo está formado por (con un ejemplo):
     * - Meta: Leer libros
     * - Cantidad: 12
     * - Unidades: libros
     * - Plazo (en meses): 12 (máximo 12)
     *
     * El cálculo del plan detallado generará la siguiente salida:
     * - Un apartado para cada mes
     * - Un listado de objetivos calculados a cumplir en cada mes
     *   (ejemplo: si quiero leer 12 libros, dará como resultado
     *   uno al mes)
     * - Cada objetivo debe poseer su nombre, la cantidad de
     *   unidades a completar en cada mes y su total. Por ejemplo:
     *
     *   Enero:
     *   [ ] 1. Leer libros (1 libro/mes). Total: 12.
     *   [ ] 2. Estudiar Git (1 curso/mes). Total: 1.
     *   Febrero:
     *   [ ] 1. Leer libros (1 libro/mes). Total: 12.
     *   ...
     *   Diciembre:
     *   [ ] 1. Leer libros (1 libro/mes). Total: 12.
     *
     * - Si la duración es menor a un año, finalizará en el mes
     *   correspondiente.
     *
     * Por último, el cálculo detallado debe poder exportarse a .txt
     * (No subir el fichero)
     */

    /*
     * EJERCICIO:
     * Papá Noel tiene que comenzar a repartir los regalos...
     * ¡Pero ha olvidado el código secreto de apertura del almacén!
     *
     * Crea un programa donde introducir códigos y obtener pistas.
     *
     * Código:
     * - El código es una combinación de letras y números aleatorios
     *   de longitud 4. (Letras: de la A a la C, Números: del 1 al 3)
     * - No hay repetidos.
     * - Se genera de manera aleatoria al iniciar el programa.
     *
     * Usuario:
     * - Dispone de 10 intentos para acertarlo.
     * - En cada turno deberá escribir un código de 4 caracteres, y
     *   el programa le indicará para cada uno lo siguiente:
     *   - Correcto: Si el caracter está en la posición correcta.
     *   - Presente: Si el caracter existe, pero esa no es su posición.
     *   - Incorrecto: Si el caracter no existe en el código secreto.
     * - Deben controlarse errores de longitud y caracteres soportados.
     *
     * Finalización:
     * - Papa Noel gana si descrifra el código antes de 10 intentos.
     * - Pierde si no lo logra, ya que no podría entregar los regalos.
     */

    /*
     * EJERCICIO:
     * ¡Ha comenzado diciembre! Es hora de montar nuestro
     * árbol de Navidad...
     *
     * Desarrolla un programa que cree un árbol de Navidad
     * con una altura dinámica definida por el usuario por terminal.
     *
     * Ejemplo de árbol de altura 5 (el tronco siempre será igual):
     *
     *     *
     *    ***
     *   *****
     *  *******
     * *********
     *    |||
     *    |||
     *
     * El usuario podrá seleccionar las siguientes acciones:
     *
     * - Añadir o eliminar la estrella en la copa del árbol (@)
     * - Añadir o eliminar bolas de dos en dos (o) aleatoriamente
     * - Añadir o eliminar luces de tres en tres (+) aleatoriamente
     * - Apagar (*) o encender (+) las luces (conservando su posición)
     * - Una luz y una bola no pueden estar en el mismo sitio
     *
     * Sólo puedes añadir una estrella, y tantas luces o bolas
     * como tengan cabida en el árbol. El programa debe notificar
     * cada una de las acciones (o por el contrario, cuando no
     * se pueda realizar alguna).
     */

    /*
     * EJERCICIO:
     * ¡Cada año celebramos el aDEViento! 24 días, 24 regalos para
     * developers. Del 1 al 24 de diciembre: https://adviento.dev
     *
     * Dibuja un calendario por terminal e implementa una
     * funcionalidad para seleccionar días y mostrar regalos.
     * - El calendario mostrará los días del 1 al 24 repartidos
     *   en 6 columnas a modo de cuadrícula.
     * - Cada cuadrícula correspondiente a un día tendrá un tamaño
     *   de 4x3 caracteres, y sus bordes serán asteríscos.
     * - Las cuadrículas dejarán un espacio entre ellas.
     * - En el medio de cada cuadrícula aparecerá el día entre el
     *   01 y el 24.
     *
     * Ejemplo de cuadrículas:
     * **** **** ****
     * *01* *02* *03* ...
     * **** **** ****
     *
     * - El usuario seleccioná qué día quiere descubrir.
     * - Si está sin descubrir, se le dirá que ha abierto ese día
     *   y se mostrará de nuevo el calendario con esa cuadrícula
     *   cubierta de asteríscos (sin mostrar el día).
     *
     * Ejemplo de selección del día 1
     * **** **** ****
     * **** *02* *03* ...
     * **** **** ****
     *
     * - Si se selecciona un número ya descubierto, se le notifica
     *   al usuario.
     */

    /*
     * EJERCICIO:
     * La alternativa descentralizada a X, Bluesky, comienza a atraer
     * a nuevos usuarios. ¿Cómo funciona una red de este estilo?
     *
     * Implementa un sistema que simule el comportamiento de estas
     * redes sociales.
     *
     * Debes crear las siguientes operaciones:
     * - Registrar un usuario por nombre e identificador único.
     * - Un usuario puede seguir/dejar de seguir a otro.
     * - Creación de post asociado a un usuario. Debe poseer
     *   texto (200 caracteres máximo), fecha de creación
     *   e identificador único.
     * - Eliminación de un post.
     * - Posibilidad de hacer like (y eliminarlo) en un post.
     * - Visualización del feed de un usuario con sus 10 publicaciones
     *   más actuales ordenadas desde la más reciente.
     * - Visualización del feed de un usuario con las 10 publicaciones
     *   más actuales de los usuarios que sigue ordenadas
     *   desde la más reciente.
     *
     * Cuando se visualiza un post, debe mostrarse:
     * ID de usuario, nombre de usuario, texto del post,
     * fecha de creación y número total de likes.
     *
     * Controla errores en duplicados o acciones no permitidas.
     */

    /*
     * EJERCICIO:
     * GitHub ha publicado el Octoverse 2024, el informe
     * anual del estado de la plataforma:
     * https://octoverse.github.com
     *
     * Utilizando el API de GitHub, crea un informe asociado
     * a un usuario concreto.
     *
     * - Se debe poder definir el nombre del usuario
     *   sobre el que se va a generar el informe.
     *
     * - Crea un informe de usuario basándote en las 5 métricas
     *   que tú quieras, utilizando la informración que te
     *   proporciona GitHub. Por ejemplo:
     *   - Lenguaje más utilizado
     *   - Cantidad de repositorios
     *   - Seguidores/Seguidos
     *   - Stars/forks
     *   - Contribuciones
     *   (lo que se te ocurra)
     */

    /*
     * EJERCICIO:
     * ¡El 12 de noviembre lanzo mouredev pro!
     * El campus de la comunidad para estudiar programación de
     * una manera diferente: https://mouredev.pro
     *
     * Crea un programa que funcione como una cuenta atrás.
     *
     * - Al iniciarlo tendrás que indicarle el día, mes, año,
     *   hora, minuto y segundo en el que quieres que finalice.
     * - Deberás transformar esa fecha local a UTC.
     * - La cuenta atrás comenzará y mostrará los días, horas,
     *   minutos y segundos que faltan.
     * - Se actualizará cada segundo y borrará la terminal en
     *   cada nueva representación del tiempo restante.
     * - Una vez finalice, mostrará un mensaje.
     * - Realiza la ejecución, si el lenguaje lo soporta, en
     *   un hilo independiente.
     */

    /*
     * EJERCICIO:
     * ¡Me voy de viaje al GitHub Universe 2024 de San Francisco!
     *
     * Desarrolla un CLI (Command Line Interface) que permita
     * interactuar con Git y GitHub de manera real desde terminal.
     *
     * El programa debe permitir las siguientes opciones:
     * 1. Establecer el directorio de trabajo
     * 2. Crear un nuevo repositorio
     * 3. Crear una nueva rama
     * 4. Cambiar de rama
     * 5. Mostrar ficheros pendientes de hacer commit
     * 6. Hacer commit (junto con un add de todos los ficheros)
     * 7. Mostrar el historial de commits
     * 8. Eliminar rama
     * 9. Establecer repositorio remoto
     * 10. Hacer pull
     * 11. Hacer push
     * 12. Salir
     *
     * Puedes intentar controlar los diferentes errores.
     */

    /*
     * EJERCICIO:
     * ¡El último videojuego de Dragon Ball ya está aquí!
     * Se llama Dragon Ball: Sparking! ZERO.
     *
     * Simula un Torneo de Artes Marciales, al más puro estilo
     * de la saga, donde participarán diferentes luchadores, y el
     * sistema decidirá quién es el ganador.
     *
     * Luchadores:
     * - Nombre.
     * - Tres atributos: velocidad, ataque y defensa
     *   (con valores entre 0 a 100 que tú decidirás).
     * - Comienza cada batalla con 100 de salud.
     * Batalla:
     * - En cada batalla se enfrentan 2 luchadores.
     * - El luchador con más velocidad comienza atacando.
     * - El daño se calcula restando el daño de ataque del
     *   atacante menos la defensa del oponente.
     * - El oponente siempre tiene un 20% de posibilidad de
     *   esquivar el ataque.
     * - Si la defensa es mayor que el ataque, recibe un 10%
     *   del daño de ataque.
     * - Después de cada turno y ataque, el oponente pierde salud.
     * - La batalla finaliza cuando un luchador pierde toda su salud.
     * Torneo:
     * - Un torneo sólo es válido con un número de luchadores
     *   potencia de 2.
     * - El torneo debe crear parejas al azar en cada ronda.
     * - Los luchadores se enfrentan en rondas eliminatorias.
     * - El ganador avanza a la siguiente ronda hasta que sólo
     *   quede uno.
     * - Debes mostrar por consola todo lo que sucede en el torneo,
     *   así como el ganador.
     */

    /*
     * EJERCICIO:
     * ¿Has visto la camiseta.rar?
     * https://x.com/MoureDev/status/1841531938961592740
     *
     * Crea un programa capaz de comprimir un archivo
     * en formato .zip (o el que tú quieras).
     * - No subas el archivo o el zip.
     */

    /*
     * EJERCICIO:
     * ¡Rubius tiene su propia skin en Fortnite!
     * Y va a organizar una competición para celebrarlo.
     * Esta es la lista de participantes:
     * https://x.com/Rubiu5/status/1840161450154692876
     *
     * Desarrolla un programa que obtenga el número de seguidores en
     * Twitch de cada participante, la fecha de creación de la cuenta
     * y ordene los resultados en dos listados.
     * - Usa el API de Twitch: https://dev.twitch.tv/docs/api/reference
     *   (NO subas las credenciales de autenticación)
     * - Crea un ranking por número de seguidores y por antigüedad.
     * - Si algún participante no tiene usuario en Twitch, debe reflejarlo.
     */

    /*
     * EJERCICIO:
     * Cada año se celebra el Batman Day durante la tercera semana de septiembre...
     * ¡Y este año cumple 85 años! Te propongo un reto doble:
     *
     * RETO 1:
     * Crea un programa que calcule cuándo se va a celebrar el Batman Day hasta
     * su 100 aniversario.
     *
     * RETO 2:
     * Crea un programa que implemente el sistema de seguridad de la Batcueva.
     * Este sistema está diseñado para monitorear múltiples sensores distribuidos
     * por Gotham, detectar intrusos y activar respuestas automatizadas.
     * Cada sensor reporta su estado en tiempo real, y Batman necesita un programa
     * que procese estos datos para tomar decisiones estratégicas.
     * Requisitos:
     * - El mapa de Gotham y los sensores se representa con una cuadrícula 20x20.
     * - Cada sensor se identifica con una coordenada (x, y) y un nivel
     *   de amenaza entre 0 a 10 (número entero).
     * - Batman debe concentrar recursos en el área más crítica de Gotham.
     * - El programa recibe un listado de tuplas representando coordenadas de los
     *   sensores y su nivel de amenaza. El umbral de activación del protocolo de
     *   seguridad es 20 (sumatorio de amenazas en una cuadrícula 3x3).
     * Acciones:
     * - Identifica el área con mayor concentración de amenazas
     *   (sumatorio de amenazas en una cuadrícula 3x3).
     * - Si el sumatorio de amenazas es mayor al umbral, activa el
     *   protocolo de seguridad.
     * - Calcula la distancia desde la Batcueva, situada en (0, 0). La distancia es
     *   la suma absoluta de las coordenadas al centro de la cuadrícula amenazada.
     * - Muestra la coordenada al centro de la cuadrícula más amenazada, la suma de
     *   sus amenazas, la distancia a la Batcueva y si se debe activar el
     *   protocolo de seguridad.
     */

    /*
     * EJERCICIO:
     * He presentado mi proyecto más importante del año: mouredev pro.
     * Un campus para la comunidad, que lanzaré en octubre, donde estudiar
     * programación de una manera diferente.
     * Cualquier persona suscrita a la newsletter de https://mouredev.pro
     * accederá a sorteos mensuales de suscripciones, regalos y descuentos.
     *
     * Desarrolla un programa que lea los registros de un fichero .csv y
     * seleccione de manera aleatoria diferentes ganadores.
     * Requisitos:
     * 1. Crea un .csv con 3 columnas: id, email y status con valor "activo"
     *    o "inactivo" (y datos ficticios).
     *    Ejemplo: 1 | test@test.com | activo
     *             2 | test2@test.com | inactivo
     *    (El .csv no debe subirse como parte de la corrección)
     * 2. Recupera los datos desde el programa y selecciona email aleatorios.
     * Acciones:
     * 1. Accede al fichero .csv y selecciona de manera aleatoria un email
     *    ganador de una suscripción, otro ganador de un descuento y un último
     *    ganador de un libro (sólo si tiene status "activo" y no está repetido).
     * 2. Muestra los emails ganadores y su id.
     * 3. Ten en cuenta que la primera fila (con el nombre de las columnas)
     *    no debe tenerse en cuenta.
     */

    /*
     * EJERCICIO:
     * Oasis y Linkin Park han anunciado nueva gira, pero, ¿quién es más popular?
     * ¡Dos de las bandas más grandes de la historia están de vuelta!
     * Desarrolla un programa que se conecte al API de Spotify y los compare.
     * Requisitos:
     * 1. Crea una cuenta de desarrollo en https://developer.spotify.com.
     * 2. Conéctate al API utilizando tu lenguaje de programación.
     * 3. Recupera datos de los endpoint que tú quieras.
     * Acciones:
     * 1. Accede a las estadísticas de las dos bandas.
     *    Por ejemplo: número total de seguidores, escuchas mensuales,
     *    canción con más reproducciones...
     * 2. Compara los resultados de, por lo menos, 3 endpoint.
     * 3. Muestra todos los resultados por consola para notificar al usuario.
     * 4. Desarrolla un criterio para seleccionar qué banda es más popular.
     */

    /*
     * EJERCICIO:
     * Cada 1 de septiembre, el Hogwarts Express parte hacia la escuela
     * de programación de Hogwarts para magos y brujas del código.
     * En ella, su famoso sombrero seleccionador ayuda a los programadores
     * a encontrar su camino...
     * Desarrolla un programa que simule el comportamiento del sombrero.
     * Requisitos:
     * 1. El sombrero realizará 10 preguntas para determinar la casa del alumno.
     * 2. Deben existir 4 casas. Por ejemplo: Frontend, Backend, Mobile y Data.
     *    (Puedes elegir las que quieras)
     * Acciones:
     * 1. Crea un programa que solicite el nombre del alumno y realice 10
     *    preguntas, con cuatro posibles respuestas cada una.
     * 2. Cada respuesta asigna puntos a cada una de las casas (a tu elección).
     * 3. Una vez finalizado, el sombrero indica el nombre del alumno
     *    y a qué casa pertenecerá (resuelve el posible empate de manera aleatoria,
     *    pero indicándole al alumno que la decisión ha sido complicada).
     */

    /*
     * EJERCICIO:
     * ¡La temporada 2 de "Los Anillos de Poder" está a punto de estrenarse!
     * ¿Qué pasaría si tuvieras que encargarte de repartir los anillos
     * entre las razas de la Tierra Media?
     * Desarrolla un programa que se encargue de distribuirlos.
     * Requisitos:
     * 1. Los Elfos recibirán un número impar.
     * 2. Los Enanos un número primo.
     * 3. Los Hombres un número par.
     * 4. Sauron siempre uno.
     * Acciones:
     * 1. Crea un programa que reciba el número total de anillos
     *    y busque una posible combinación para repartirlos.
     * 2. Muestra el reparto final o el error al realizarlo.
     */

    /*
     * EJERCICIO:
     * ¡La Casa del Dragón ha finalizado y no volverá hasta 2026!
     * ¿Alguien se entera de todas las relaciones de parentesco
     * entre personajes que aparecen en la saga?
     * Desarrolla un árbol genealógico para relacionarlos (o invéntalo).
     * Requisitos:
     * 1. Estará formado por personas con las siguientes propiedades:
     *    - Identificador único (obligatorio)
     *    - Nombre (obligatorio)
     *    - Pareja (opcional)
     *    - Hijos (opcional)
     * 2. Una persona sólo puede tener una pareja (para simplificarlo).
     * 3. Las relaciones deben validarse dentro de lo posible.
     *    Ejemplo: Un hijo no puede tener tres padres.
     * Acciones:
     * 1. Crea un programa que permita crear y modificar el árbol.
     *    - Añadir y eliminar personas
     *    - Modificar pareja e hijo
     * 2. Podrás imprimir el árbol (de la manera que consideres).
     *
     * NOTA: Ten en cuenta que la complejidad puede ser alta si
     * se implementan todas las posibles relaciones. Intenta marcar
     * tus propias reglas y límites para que te resulte asumible.
     */

    /*
     * EJERCICIO:
     * ¡Disney ha presentado un montón de novedades en su D23!
     * Pero... ¿Dónde está Mickey?
     * Mickey Mouse ha quedado atrapado en un laberinto mágico
     * creado por Maléfica.
     * Desarrolla un programa para ayudarlo a escapar.
     * Requisitos:
     * 1. El laberinto está formado por un cuadrado de 6x6 celdas.
     * 2. Los valores de las celdas serán:
     *    - ⬜️ Vacío
     *    - ⬛️ Obstáculo
     *    - 🐭 Mickey
     *    - 🚪 Salida
     * Acciones:
     * 1. Crea una matriz que represente el laberinto (no hace falta
     * que se genere de manera automática).
     * 2. Interactúa con el usuario por consola para preguntarle hacia
     * donde se tiene que desplazar (arriba, abajo, izquierda o derecha).
     * 3. Muestra la actualización del laberinto tras cada desplazamiento.
     * 4. Valida todos los movimientos, teniendo en cuenta los límites
     * del laberinto y los obtáculos. Notifica al usuario.
     * 5. Finaliza el programa cuando Mickey llegue a la salida.
     */

    /*
     * EJERCICIO:
     * ¡Deadpool y Wolverine se enfrentan en una batalla épica!
     * Crea un programa que simule la pelea y determine un ganador.
     * El programa simula un combate por turnos, donde cada protagonista posee unos
     * puntos de vida iniciales, un daño de ataque variable y diferentes cualidades
     * de regeneración y evasión de ataques.
     * Requisitos:
     * 1. El usuario debe determinar la vida inicial de cada protagonista.
     * 2. Cada personaje puede impartir un daño aleatorio:
     *    - Deadpool: Entre 10 y 100.
     *    - Wolverine: Entre 10 y 120.
     * 3. Si el daño es el máximo, el personaje que lo recibe no ataca en el
     * siguiente turno, ya que tiene que regenerarse (pero no aumenta vida).
     * 4. Cada personaje puede evitar el ataque contrario:
     *    - Deadpool: 25% de posibilidades.
     *    - Wolverine: 20% de posibilidades.
     * 5. Un personaje pierde si sus puntos de vida llegan a cero o menos.
     * Acciones:
     * 1. Simula una batalla.
     * 2. Muestra el número del turno (pausa de 1 segundo entre turnos).
     * 3. Muestra qué pasa en cada turno.
     * 4. Muestra la vida en cada turno.
     * 5. Muestra el resultado final.
     */

    /*
     * EJERCICIO:
     * ¡Los JJOO de París 2024 han comenzado!
     * Crea un programa que simule la celebración de los juegos.
     * El programa debe permitir al usuario registrar eventos y participantes,
     * realizar la simulación de los eventos asignando posiciones de manera aleatoria
     * y generar un informe final. Todo ello por terminal.
     * Requisitos:
     * 1. Registrar eventos deportivos.
     * 2. Registrar participantes por nombre y país.
     * 3. Simular eventos de manera aleatoria en base a los participantes (mínimo 3).
     * 4. Asignar medallas (oro, plata y bronce) basándose en el resultado del evento.
     * 5. Mostrar los ganadores por cada evento.
     * 6. Mostrar el ranking de países según el número de medallas.
     * Acciones:
     * 1. Registro de eventos.
     * 2. Registro de participantes.
     * 3. Simulación de eventos.
     * 4. Creación de informes.
     * 5. Salir del programa.
     */

    /*
     * EJERCICIO:
     * Explora el "Principio SOLID de Inversión de Dependencias (Dependency Inversion
     * Principle, DIP)" y crea un ejemplo simple donde se muestre su funcionamiento
     * de forma correcta e incorrecta.
     *
     * DIFICULTAD EXTRA (opcional):
     * Crea un sistema de notificaciones.
     * Requisitos:
     * 1. El sistema puede enviar Email, PUSH y SMS (implementaciones específicas).
     * 2. El sistema de notificaciones no puede depender de las implementaciones específicas.
     * Instrucciones:
     * 1. Crea la interfaz o clase abstracta.
     * 2. Desarrolla las implementaciones específicas.
     * 3. Crea el sistema de notificaciones usando el DIP.
     * 4. Desarrolla un código que compruebe que se cumple el principio.
     */

    /*
     * EJERCICIO:
     * Explora el "Principio SOLID de Segregación de Interfaces
     * (Interface Segregation Principle, ISP)", y crea un ejemplo
     * simple donde se muestre su funcionamiento de forma correcta e incorrecta.
     *
     * DIFICULTAD EXTRA (opcional):
     * Crea un gestor de impresoras.
     * Requisitos:
     * 1. Algunas impresoras sólo imprimen en blanco y negro.
     * 2. Otras sólo a color.
     * 3. Otras son multifunción, pueden imprimir, escanear y enviar fax.
     * Instrucciones:
     * 1. Implementa el sistema, con los diferentes tipos de impresoras y funciones.
     * 2. Aplica el ISP a la implementación.
     * 3. Desarrolla un código que compruebe que se cumple el principio.
     */

    /*
     * EJERCICIO:
     * Explora el "Principio SOLID de Sustitución de Liskov (Liskov Substitution Principle, LSP)"
     * y crea un ejemplo simple donde se muestre su funcionamiento
     * de forma correcta e incorrecta.
     *
     * DIFICULTAD EXTRA (opcional):
     * Crea una jerarquía de vehículos. Todos ellos deben poder acelerar y frenar, así como
     * cumplir el LSP.
     * Instrucciones:
     * 1. Crea la clase Vehículo.
     * 2. Añade tres subclases de Vehículo.
     * 3. Implementa las operaciones "acelerar" y "frenar" como corresponda.
     * 4. Desarrolla un código que compruebe que se cumple el LSP.
     */

    /*
     * EJERCICIO:
     * Explora el "Principio SOLID Abierto-Cerrado (Open-Close Principle, OCP)"
     * y crea un ejemplo simple donde se muestre su funcionamiento
     * de forma correcta e incorrecta.
     *
     * DIFICULTAD EXTRA (opcional):
     * Desarrolla una calculadora que necesita realizar diversas operaciones matemáticas.
     * Requisitos:
     * - Debes diseñar un sistema que permita agregar nuevas operaciones utilizando el OCP.
     * Instrucciones:
     * 1. Implementa las operaciones de suma, resta, multiplicación y división.
     * 2. Comprueba que el sistema funciona.
     * 3. Agrega una quinta operación para calcular potencias.
     * 4. Comprueba que se cumple el OCP.
     */

    /*
     * EJERCICIO:
     * Explora el "Principio SOLID de Responsabilidad Única (Single Responsibility
     * Principle, SRP)" y crea un ejemplo simple donde se muestre su funcionamiento
     * de forma correcta e incorrecta.
     *
     * DIFICULTAD EXTRA (opcional):
     * Desarrolla un sistema de gestión para una biblioteca. El sistema necesita
     * manejar diferentes aspectos como el registro de libros, la gestión de usuarios
     * y el procesamiento de préstamos de libros.
     * Requisitos:
     * 1. Registrar libros: El sistema debe permitir agregar nuevos libros con
     * información básica como título, autor y número de copias disponibles.
     * 2. Registrar usuarios: El sistema debe permitir agregar nuevos usuarios con
     * información básica como nombre, número de identificación y correo electrónico.
     * 3. Procesar préstamos de libros: El sistema debe permitir a los usuarios
     * tomar prestados y devolver libros.
     * Instrucciones:
     * 1. Diseña una clase que no cumple el SRP: Crea una clase Library que maneje
     * los tres aspectos mencionados anteriormente (registro de libros, registro de
     * usuarios y procesamiento de préstamos).
     * 2. Refactoriza el código: Separa las responsabilidades en diferentes clases
     * siguiendo el Principio de Responsabilidad Única.
     */

    /*
     * EJERCICIO:
     * Explora el concepto de "logging" en tu lenguaje. Configúralo y muestra
     * un ejemplo con cada nivel de "severidad" disponible.
     *
     * DIFICULTAD EXTRA (opcional):
     * Crea un programa ficticio de gestión de tareas que permita añadir, eliminar
     * y listar dichas tareas.
     * - Añadir: recibe nombre y descripción.
     * - Eliminar: por nombre de la tarea.
     * Implementa diferentes mensajes de log que muestren información según la
     * tarea ejecutada (a tu elección).
     * Utiliza el log para visualizar el tiempo de ejecución de cada tarea.
     */

    /*
     * EJERCICIO:
     * Explora el concepto de "decorador" y muestra cómo crearlo
     * con un ejemplo genérico.
     *
     * DIFICULTAD EXTRA (opcional):
     * Crea un decorador que sea capaz de contabilizar cuántas veces
     * se ha llamado a una función y aplícalo a una función de tu elección.
     */

    /*
     * EJERCICIO:
     * Explora el patrón de diseño "singleton" y muestra cómo crearlo
     * con un ejemplo genérico.
     *
     * DIFICULTAD EXTRA (opcional):
     * Utiliza el patrón de diseño "singleton" para representar una clase que
     * haga referencia a la sesión de usuario de una aplicación ficticia.
     * La sesión debe permitir asignar un usuario (id, username, nombre y email),
     * recuperar los datos del usuario y borrar los datos de la sesión.
     */

    /*
     * EJERCICIO:
     * Explora el concepto de funciones de orden superior en tu lenguaje
     * creando ejemplos simples (a tu elección) que muestren su funcionamiento.
     *
     * DIFICULTAD EXTRA (opcional):
     * Dada una lista de estudiantes (con sus nombres, fecha de nacimiento y
     * lista de calificaciones), utiliza funciones de orden superior para
     * realizar las siguientes operaciones de procesamiento y análisis:
     * - Promedio calificaciones: Obtiene una lista de estudiantes por nombre
     *   y promedio de sus calificaciones.
     * - Mejores estudiantes: Obtiene una lista con el nombre de los estudiantes
     *   que tienen calificaciones con un 9 o más de promedio.
     * - Nacimiento: Obtiene una lista de estudiantes ordenada desde el más joven.
     * - Mayor calificación: Obtiene la calificación más alta de entre todas las
     *   de los alumnos.
     * - Una calificación debe estar comprendida entre 0 y 10 (admite decimales).
     */

    /*
     * EJERCICIO:
     * Explora el concepto de callback en tu lenguaje creando un ejemplo
     * simple (a tu elección) que muestre su funcionamiento.
     *
     * DIFICULTAD EXTRA (opcional):
     * Crea un simulador de pedidos de un restaurante utilizando callbacks.
     * Estará formado por una función que procesa pedidos.
     * Debe aceptar el nombre del plato, una callback de confirmación, una
     * de listo y otra de entrega.
     * - Debe imprimir un confirmación cuando empiece el procesamiento.
     * - Debe simular un tiempo aleatorio entre 1 a 10 segundos entre
     *   procesos.
     * - Debe invocar a cada callback siguiendo un orden de procesado.
     * - Debe notificar que el plato está listo o ha sido entregado.
     */

    /*
     * EJERCICIO:
     * Utilizando un mecanismo de peticiones HTTP de tu lenguaje, realiza
     * una petición a la web que tú quieras, verifica que dicha petición
     * fue exitosa y muestra por consola el contenido de la web.
     *
     * DIFICULTAD EXTRA (opcional):
     * Utilizando la PokéAPI (https://pokeapi.co), crea un programa por
     * terminal al que le puedas solicitar información de un Pokémon concreto
     * utilizando su nombre o número.
     * - Muestra el nombre, id, peso, altura y tipo(s) del Pokémon
     * - Muestra el nombre de su cadena de evoluciones
     * - Muestra los juegos en los que aparece
     * - Controla posibles errores
     */

    /*
     * EJERCICIO:
     * Empleando tu lenguaje, explora la definición del tipo de dato
     * que sirva para definir enumeraciones (Enum).
     * Crea un Enum que represente los días de la semana del lunes
     * al domingo, en ese orden. Con ese enumerado, crea una operación
     * que muestre el nombre del día de la semana dependiendo del número entero
     * utilizado (del 1 al 7).
     *
     * DIFICULTAD EXTRA (opcional):
     * Crea un pequeño sistema de gestión del estado de pedidos.
     * Implementa una clase que defina un pedido con las siguientes características:
     * - El pedido tiene un identificador y un estado.
     * - El estado es un Enum con estos valores: PENDIENTE, ENVIADO, ENTREGADO y CANCELADO.
     * - Implementa las funciones que sirvan para modificar el estado:
     *   - Pedido enviado
     *   - Pedido cancelado
     *   - Pedido entregado
     *   (Establece una lógica, por ejemplo, no se puede entregar si no se ha enviado, etc...)
     * - Implementa una función para mostrar un texto descriptivo según el estado actual.
     * - Crea diferentes pedidos y muestra cómo se interactúa con ellos.
     */

    /*
     * EJERCICIO:
     * Utilizando tu lenguaje crea un conjunto de datos y realiza las siguientes
     * operaciones (debes utilizar una estructura que las soporte):
     * - Añade un elemento al final.
     * - Añade un elemento al principio.
     * - Añade varios elementos en bloque al final.
     * - Añade varios elementos en bloque en una posición concreta.
     * - Elimina un elemento en una posición concreta.
     * - Actualiza el valor de un elemento en una posición concreta.
     * - Comprueba si un elemento está en un conjunto.
     * - Elimina todo el contenido del conjunto.
     *
     * DIFICULTAD EXTRA (opcional):
     * Muestra ejemplos de las siguientes operaciones con conjuntos:
     * - Unión.
     * - Intersección.
     * - Diferencia.
     * - Diferencia simétrica.
     */

    /*
     * EJERCICIO:
     * Utilizando tu lenguaje, emplea 3 mecanismos diferentes para imprimir
     * números del 1 al 10 mediante iteración.
     *
     * DIFICULTAD EXTRA (opcional):
     * Escribe el mayor número de mecanismos que posea tu lenguaje
     * para iterar valores. ¿Eres capaz de utilizar 5? ¿Y 10?
     */

    /*
     * EJERCICIO:
     * Utilizando tu lenguaje, explora el concepto de expresiones regulares,
     * creando una que sea capaz de encontrar y extraer todos los números
     * de un texto.
     *
     * DIFICULTAD EXTRA (opcional):
     * Crea 3 expresiones regulares (a tu criterio) capaces de:
     * - Validar un email.
     * - Validar un número de teléfono.
     * - Validar una url.
     */

    /*
     * EJERCICIO:
     * Utilizando tu lenguaje, crea un programa capaz de ejecutar de manera
     * asíncrona una función que tardará en finalizar un número concreto de
     * segundos parametrizables. También debes poder asignarle un nombre.
     * La función imprime su nombre, cuándo empieza, el tiempo que durará
     * su ejecución y cuando finaliza.
     *
     * DIFICULTAD EXTRA (opcional):
     * Utilizando el concepto de asincronía y la función anterior, crea
     * el siguiente programa que ejecuta en este orden:
     * - Una función C que dura 3 segundos.
     * - Una función B que dura 2 segundos.
     * - Una función A que dura 1 segundo.
     * - Una función D que dura 1 segundo.
     * - Las funciones C, B y A se ejecutan en paralelo.
     * - La función D comienza su ejecución cuando las 3 anteriores han finalizado.
     */

    /*
     * EJERCICIO:
     * Crea dos variables utilizando los objetos fecha (date, o semejante) de tu lenguaje:
     * - Una primera que represente la fecha (día, mes, año, hora, minuto, segundo) actual.
     * - Una segunda que represente tu fecha de nacimiento (te puedes inventar la hora).
     * Calcula cuántos años han transcurrido entre ambas fechas.
     *
     * DIFICULTAD EXTRA (opcional):
     * Utilizando la fecha de tu cumpleaños, formatéala y muestra su resultado de
     * 10 maneras diferentes. Por ejemplo:
     * - Día, mes y año.
     * - Hora, minuto y segundo.
     * - Día de año.
     * - Día de la semana.
     * - Nombre del mes.
     * (lo que se te ocurra...)
     */

    /*
     * EJERCICIO:
     * Crea una función que se encargue de sumar dos números y retornar
     * su resultado.
     * Crea un test, utilizando las herramientas de tu lenguaje, que sea
     * capaz de determinar si esa función se ejecuta correctamente.
     *
     * DIFICULTAD EXTRA (opcional):
     * Crea un diccionario con las siguientes claves y valores:
     * "name": "Tu nombre"
     * "age": "Tu edad"
     * "birth_date": "Tu fecha de nacimiento"
     * "programming_languages": ["Listado de lenguajes de programación"]
     * Crea dos test:
     * - Un primero que determine que existen todos los campos.
     * - Un segundo que determine que los datos introducidos son correctos.
     */

    /*
     * IMPORTANTE: Sólo debes subir el fichero de código como parte del ejercicio.
     *
     * EJERCICIO:
     * Desarrolla un programa capaz de crear un archivo XML y JSON que guarde los
     * siguientes datos (haciendo uso de la sintaxis correcta en cada caso):
     * - Nombre
     * - Edad
     * - Fecha de nacimiento
     * - Listado de lenguajes de programación
     * Muestra el contenido de los archivos.
     * Borra los archivos.
     *
     * DIFICULTAD EXTRA (opcional):
     * Utilizando la lógica de creación de los archivos anteriores, crea un
     * programa capaz de leer y transformar en una misma clase custom de tu
     * lenguaje los datos almacenados en el XML y el JSON.
     * Borra los archivos.
     */

    /*
     * IMPORTANTE: Sólo debes subir el fichero de código como parte del ejercicio.
     *
     * EJERCICIO:
     * Desarrolla un programa capaz de crear un archivo que se llame como
     * tu usuario de GitHub y tenga la extensión .txt.
     * Añade varias líneas en ese fichero:
     * - Tu nombre.
     * - Edad.
     * - Lenguaje de programación favorito.
     * Imprime el contenido.
     * Borra el fichero.
     *
     * DIFICULTAD EXTRA (opcional):
     * Desarrolla un programa de gestión de ventas que almacena sus datos en un
     * archivo .txt.
     * - Cada producto se guarda en una línea del archivo de la siguiente manera:
     *   [nombre_producto], [cantidad_vendida], [precio].
     * - Siguiendo ese formato, y mediante terminal, debe permitir añadir, consultar,
     *   actualizar, eliminar productos y salir.
     * - También debe poseer opciones para calcular la venta total y por producto.
     * - La opción salir borra el .txt.
     */

    /*
     * EJERCICIO:
     * Explora el concepto de manejo de excepciones según tu lenguaje.
     * Fuerza un error en tu código, captura el error, imprime dicho error
     * y evita que el programa se detenga de manera inesperada.
     * Prueba a dividir "10/0" o acceder a un índice no existente
     * de un listado para intentar provocar un error.
     *
     * DIFICULTAD EXTRA (opcional):
     * Crea una función que sea capaz de procesar parámetros, pero que también
     * pueda lanzar 3 tipos diferentes de excepciones (una de ellas tiene que
     * corresponderse con un tipo de excepción creada por nosotros de manera
     * personalizada, y debe ser lanzada de manera manual) en caso de error.
     * - Captura todas las excepciones desde el lugar donde llamas a la función.
     * - Imprime el tipo de error.
     * - Imprime si no se ha producido ningún error.
     * - Imprime que la ejecución ha finalizado.
     */

    /*
     * EJERCICIO:
     * Explora el concepto de herencia según tu lenguaje. Crea un ejemplo que
     * implemente una superclase Animal y un par de subclases Perro y Gato,
     * junto con una función que sirva para imprimir el sonido que emite cada Animal.
     *
     * DIFICULTAD EXTRA (opcional):
     * Implementa la jerarquía de una empresa de desarrollo formada por Empleados que
     * pueden ser Gerentes, Gerentes de Proyectos o Programadores.
     * Cada empleado tiene un identificador y un nombre.
     * Dependiendo de su labor, tienen propiedades y funciones exclusivas de su
     * actividad, y almacenan los empleados a su cargo.
     */

    /*
     * EJERCICIO:
     * Explora el concepto de clase y crea un ejemplo que implemente un inicializador,
     * atributos y una función que los imprima (teniendo en cuenta las posibilidades
     * de tu lenguaje).
     * Una vez implementada, créala, establece sus parámetros, modifícalos e imprímelos
     * utilizando su función.
     *
     * DIFICULTAD EXTRA (opcional):
     * Implementa dos clases que representen las estructuras de Pila y Cola (estudiadas
     * en el ejercicio número 7 de la ruta de estudio)
     * - Deben poder inicializarse y disponer de operaciones para añadir, eliminar,
     *   retornar el número de elementos e imprimir todo su contenido.
     */

    /*
     * EJERCICIO:
     * Implementa los mecanismos de introducción y recuperación de elementos propios de las
     * pilas (stacks - LIFO) y las colas (queue - FIFO) utilizando una estructura de array
     * o lista (dependiendo de las posibilidades de tu lenguaje).
     *
     * DIFICULTAD EXTRA (opcional):
     * - Utilizando la implementación de pila y cadenas de texto, simula el mecanismo adelante/atrás
     *   de un navegador web. Crea un programa en el que puedas navegar a una página o indicarle
     *   que te quieres desplazar adelante o atrás, mostrando en cada caso el nombre de la web.
     *   Las palabras "adelante", "atrás" desencadenan esta acción, el resto se interpreta como
     *   el nombre de una nueva web.
     * - Utilizando la implementación de cola y cadenas de texto, simula el mecanismo de una
     *   impresora compartida que recibe documentos y los imprime cuando así se le indica.
     *   La palabra "imprimir" imprime un elemento de la cola, el resto de palabras se
     *   interpretan como nombres de documentos.
     */

    /*
     * EJERCICIO:
     * Entiende el concepto de recursividad creando una función recursiva que imprima
     * números del 100 al 0.
     *
     * DIFICULTAD EXTRA (opcional):
     * Utiliza el concepto de recursividad para:
     * - Calcular el factorial de un número concreto (la función recibe ese número).
     * - Calcular el valor de un elemento concreto (según su posición) en la
     *   sucesión de Fibonacci (la función recibe la posición).
     */

    /*
     * EJERCICIO:
     * - Muestra ejemplos de asignación de variables "por valor" y "por referencia", según
     *   su tipo de dato.
     * - Muestra ejemplos de funciones con variables que se les pasan "por valor" y
     *   "por referencia", y cómo se comportan en cada caso en el momento de ser modificadas.
     * (Entender estos conceptos es algo esencial en la gran mayoría de lenguajes)
     *
     * DIFICULTAD EXTRA (opcional):
     * Crea dos programas que reciban dos parámetros (cada uno) definidos como
     * variables anteriormente.
     * - Cada programa recibe, en un caso, dos parámetros por valor, y en otro caso, por referencia.
     *   Estos parámetros los intercambia entre ellos en su interior, los retorna, y su retorno
     *   se asigna a dos variables diferentes a las originales. A continuación, imprime
     *   el valor de las variables originales y las nuevas, comprobando que se ha invertido
     *   su valor en las segundas.
     *   Comprueba también que se ha conservado el valor original en las primeras.
     */

    /*
     * EJERCICIO:
     * Muestra ejemplos de todas las operaciones que puedes realizar con cadenas de caracteres
     * en tu lenguaje. Algunas de esas operaciones podrían ser (busca todas las que puedas):
     * - Acceso a caracteres específicos, subcadenas, longitud, concatenación, repetición,
     *   recorrido, conversión a mayúsculas y minúsculas, reemplazo, división, unión,
     *   interpolación, verificación...
     *
     * DIFICULTAD EXTRA (opcional):
     * Crea un programa que analice dos palabras diferentes y realice comprobaciones
     * para descubrir si son:
     * - Palíndromos
     * - Anagramas
     * - Isogramas
     */

    /*
     * EJERCICIO:
     * - Muestra ejemplos de creación de todas las estructuras soportadas por defecto
     *   en tu lenguaje.
     * - Utiliza operaciones de inserción, borrado, actualización y ordenación.
     *
     * DIFICULTAD EXTRA (opcional):
     * Crea una agenda de contactos por terminal.
     * - Debes implementar funcionalidades de búsqueda, inserción, actualización
     *   y eliminación de contactos.
     * - Cada contacto debe tener un nombre y un número de teléfono.
     * - El programa solicita en primer lugar cuál es la operación que se quiere realizar,
     *   y a continuación los datos necesarios para llevarla a cabo.
     * - El programa no puede dejar introducir números de teléfono no númericos y con más
     *   de 11 dígitos (o el número de dígitos que quieras).
     * - También se debe proponer una operación de finalización del programa.
     */

    /*
     * EJERCICIO:
     * - Crea ejemplos de funciones básicas que representen las diferentes
     *   posibilidades del lenguaje:
     *   Sin parámetros ni retorno, con uno o varios parámetros, con retorno...
     * - Comprueba si puedes crear funciones dentro de funciones.
     * - Utiliza algún ejemplo de funciones ya creadas en el lenguaje.
     * - Pon a prueba el concepto de variable LOCAL y GLOBAL.
     * - Debes hacer print por consola del resultado de todos los ejemplos.
     *   (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades)
     *
     * DIFICULTAD EXTRA (opcional):
     * Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número.
     * - La función imprime todos los números del 1 al 100. Teniendo en cuenta que:
     *   - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro.
     *   - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro.
     *   - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas.
     *   - La función retorna el número de veces que se ha impreso el número en lugar de los textos.
     *
     * Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos.
     * Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda.
     */

    /*
     * EJERCICIO:
     * - Crea ejemplos utilizando todos los tipos de operadores de tu lenguaje:
     *   Aritméticos, lógicos, de comparación, asignación, identidad, pertenencia, bits...
     *   (Ten en cuenta que cada lenguaje puede poseer unos diferentes)
     * - Utilizando las operaciones con operadores que tú quieras, crea ejemplos
     *   que representen todos los tipos de estructuras de control que existan
     *   en tu lenguaje:
     *   Condicionales, iterativas, excepciones...
     * - Debes hacer print por consola del resultado de todos los ejemplos.
     *
     * DIFICULTAD EXTRA (opcional):
     * Crea un programa que imprima por consola todos los números comprendidos
     * entre 10 y 55 (incluidos), pares, y que no son ni el 16 ni múltiplos de 3.
     *
     * Seguro que al revisar detenidamente las posibilidades has descubierto algo nuevo.
     */

    /*
     * ¿Preparad@ para aprender o repasar el lenguaje de programación que tú quieras?
     * - Recuerda que todas las instrucciones de participación están en el
     *   repositorio de GitHub.
     *
     * Lo primero... ¿Ya has elegido un lenguaje?
     * - No todos son iguales, pero sus fundamentos suelen ser comunes.
     * - Este primer reto te servirá para familiarizarte con la forma de participar
     *   enviando tus propias soluciones.
     *
     * EJERCICIO:
     * - Crea un comentario en el código y coloca la URL del sitio web oficial del
     *   lenguaje de programación que has seleccionado.
     * - Representa las diferentes sintaxis que existen de crear comentarios
     *   en el lenguaje (en una línea, varias...).
     * - Crea una variable (y una constante si el lenguaje lo soporta).
     * - Crea variables representando todos los tipos de datos primitivos
     *   del lenguaje (cadenas de texto, enteros, booleanos...).
     * - Imprime por terminal el texto: "¡Hola, [y el nombre de tu lenguaje]!"
     *
     * ¿Fácil? No te preocupes, recuerda que esta es una ruta de estudio y
     * debemos comenzar por el principio.
     */

## Preguntas frecuentes

¿Cómo puedo participar en los retos?

A parte de poder consultar la corrección de los retos en código y vídeo, también puedes enviar tus propias soluciones. Consulta las instrucciones de participación en su repositorio de GitHub y pregunta a la comunidad en Discord.

¿Puedo utilizar cualquier lenguaje de programación?

Por supuesto. Lo bueno de los retos de lógica es que su principal valor es enseñarnos a pensar y seguir un razonamiento a la hora de resolver un problema. La manera de enfocarlo es independiente al lenguaje de programación.

¿Existe algún orden para resolver los ejercicios?

Los retos están organizados siguiendo una ruta de estudio que hará un repaso por todos los fundamentos comunes de la gran mayoría de lenguajes de programación usados en la actualidad. Te recomiendo seguir su numeración.

¿Cuándo se publican los retos?

Cada semana (consulta el día y la hora en esta web) se realizará una transmisión en directo resolviendo y explicando el ejercicio de la semana anterior. Hecho esto, se publicará el nuevo reto. Todo quedará grabado.

¿Y si ya tengo conocimientos?

La ruta de estudio no sólo trata de dar a conocer los fundamentos del lenguaje, si no generar una forma organizada de estudiar, practicar y mejorar tus conocimientos. Estoy seguro que de esta manerá aprenderás algo nuevo.

¿Y si mi corrección no se parece a la solución?

Ante todo, estos ejercicios sirven para poner a prueba tus habilidades, y la solución sólo es una posible opción. La tuya puede ser diferente, o incluso poseer errores, pero lo importante es que a programar se aprende programando.

¿Cómo puedo participar en los retos?

A parte de poder consultar la corrección de los retos en código y vídeo, también puedes enviar tus propias soluciones. Consulta las instrucciones de participación en su repositorio de GitHub y pregunta a la comunidad en Discord.

¿Puedo utilizar cualquier lenguaje de programación?

Por supuesto. Lo bueno de los retos de lógica es que su principal valor es enseñarnos a pensar y seguir un razonamiento a la hora de resolver un problema. La manera de enfocarlo es independiente al lenguaje de programación.

¿Existe algún orden para resolver los ejercicios?

Los retos están organizados siguiendo una ruta de estudio que hará un repaso por todos los fundamentos comunes de la gran mayoría de lenguajes de programación usados en la actualidad. Te recomiendo seguir su numeración.

¿Cuándo se publican los retos?

Cada semana (consulta el día y la hora en esta web) se realizará una transmisión en directo resolviendo y explicando el ejercicio de la semana anterior. Hecho esto, se publicará el nuevo reto. Todo quedará grabado.

¿Y si ya tengo conocimientos?

La ruta de estudio no sólo trata de dar a conocer los fundamentos del lenguaje, si no generar una forma organizada de estudiar, practicar y mejorar tus conocimientos. Estoy seguro que de esta manerá aprenderás algo nuevo.

¿Y si mi corrección no se parece a la solución?

Ante todo, estos ejercicios sirven para poner a prueba tus habilidades, y la solución sólo es una posible opción. La tuya puede ser diferente, o incluso poseer errores, pero lo importante es que a programar se aprende programando.

## Sigue practicando

## Ejercicios lógicos

## Proyectos completos

>_
Python
Swift
Kotlin
Java
C++PHP Rust Go JavaScript Dart Ruby C#TypeScript Cobol Lua C PowerShell Assembly R Objective-C F#Haskell Fortran Lisp Scala Perl Groovy Solidity Ada Plankalkül

>_Python Swift Kotlin Java C++PHP Rust Go JavaScript Dart Ruby C#TypeScript Cobol Lua C PowerShell Assembly R Objective-C F#Haskell Fortran Lisp Scala Perl Groovy Solidity Ada Plankalkül

Creado con 🤍 (y gracias a ti) por
MoureDev by Brais Moure.

© 2022-2024. v3.0.