✨ Add solution challenge-19

2024/19-enumeraciones/README.md

@@ -0,0 +1,23 @@
+# Reto 19: Enumeraciones
+
+## Enunciado
+
+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.

2024/19-enumeraciones/index.js

@@ -0,0 +1,90 @@
+/* eslint-disable max-len */
+/* eslint-disable no-console */
+const DaysOfWeek = {
+  MONDAY: 1,
+  TUESDAY: 2,
+  WEDNESDAY: 3,
+  THURSDAY: 4,
+  FRIDAY: 5,
+  SATURDAY: 6,
+  SUNDAY: 7,
+};
+
+function getDayName(dayNumber) {
+  switch (dayNumber) {
+    case DaysOfWeek.MONDAY: return 'Monday';
+    case DaysOfWeek.TUESDAY: return 'Tuesday';
+    case DaysOfWeek.WEDNESDAY: return 'Wednesday';
+    case DaysOfWeek.THURSDAY: return 'Thursday';
+    case DaysOfWeek.FRIDAY: return 'Friday';
+    case DaysOfWeek.SATURDAY: return 'Saturday';
+    case DaysOfWeek.SUNDAY: return 'Sunday';
+    default: return 'Invalid day number';
+  }
+}
+
+console.log(getDayName(1)); // Output: Monday
+console.log(getDayName(5)); // Output: Friday
+
+const OrderStatus = {
+  PENDING: 'Pending',
+  SHIPPED: 'Shipped',
+  DELIVERED: 'Delivered',
+  CANCELED: 'Canceled',
+};
+
+class Order {
+  constructor(id) {
+    this.id = id;
+    this.status = OrderStatus.PENDING;
+  }
+
+  markAsShipped() {
+    if (this.status === OrderStatus.PENDING) {
+      this.status = OrderStatus.SHIPPED;
+    } else {
+      console.log('Order cannot be shipped. Current status:', this.status);
+    }
+  }
+
+  markAsDelivered() {
+    if (this.status === OrderStatus.SHIPPED) {
+      this.status = OrderStatus.DELIVERED;
+    } else {
+      console.log('Order cannot be delivered. Current status:', this.status);
+    }
+  }
+
+  cancelOrder() {
+    if (this.status !== OrderStatus.DELIVERED) {
+      this.status = OrderStatus.CANCELED;
+    } else {
+      console.log('Order cannot be canceled. Current status:', this.status);
+    }
+  }
+
+  getStatusDescription() {
+    switch (this.status) {
+      case OrderStatus.PENDING: return 'The order is pending and awaiting shipment.';
+      case OrderStatus.SHIPPED: return 'The order has been shipped and is on its way.';
+      case OrderStatus.DELIVERED: return 'The order has been delivered to the customer.';
+      case OrderStatus.CANCELED: return 'The order has been canceled and will not be processed.';
+      default: return 'Unknown status';
+    }
+  }
+}
+
+const order1 = new Order(101);
+console.log(order1.getStatusDescription()); // Output: The order is pending and awaiting shipment.
+
+order1.markAsShipped();
+console.log(order1.getStatusDescription()); // Output: The order has been shipped and is on its way.
+
+order1.markAsDelivered();
+console.log(order1.getStatusDescription()); // Output: The order has been delivered to the customer.
+
+order1.cancelOrder(); // Output: Order cannot be canceled. Current status: Delivered
+
+const order2 = new Order(102);
+order2.cancelOrder();
+console.log(order2.getStatusDescription()); // Output: The order has been canceled and will not be processed.

2024/20-peticiones-http/README.md

@@ -0,0 +1,14 @@
+# Reto 20: Peticiones-http
+
+## Enunciado
+
+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

2024/20-peticiones-http/index.js

@@ -0,0 +1,61 @@
+/* eslint-disable no-console */
+async function fetchWebsiteContent(url) {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP error! Status: ${response.status}`);
+    }
+    const data = await response.text();
+    console.log('Request was successful!');
+    console.log('Website content:\n', data);
+  } catch (error) {
+    console.error('Failed to fetch the website content. Error:', error.message);
+  }
+}
+
+fetchWebsiteContent('https://google.com');
+
+async function fetchPokemonData(pokemon) {
+  try {
+    const response = await
+    fetch(`https://pokeapi.co/api/v2/pokemon/${pokemon.toLowerCase()}`);
+
+    if (!response.ok) {
+      throw new Error(`Pokémon not found! Status: ${response.status}`);
+    }
+
+    const pokemonData = await response.json();
+    console.log(`Name: ${pokemonData.name}`);
+    console.log(`ID: ${pokemonData.id}`);
+    console.log(`Weight: ${pokemonData.weight}`);
+    console.log(`Height: ${pokemonData.height}`);
+    console.log('Types:', pokemonData.types
+      .map((typeInfo) => typeInfo.type.name)
+      .join(', '));
+
+    // Obtener la cadena de evoluciones
+    const speciesResponse = await fetch(pokemonData.species.url);
+    const speciesData = await speciesResponse.json();
+    const evolutionResponse = await fetch(speciesData.evolution_chain.url);
+    const evolutionData = await evolutionResponse.json();
+    const evolutionChain = [];
+    let currentStage = evolutionData.chain;
+
+    while (currentStage) {
+      evolutionChain.push(currentStage.species.name);
+      const [firstEvolution] = currentStage.evolves_to;
+      currentStage = firstEvolution;
+    }
+
+    console.log('Evolution Chain:', evolutionChain.join(' -> '));
+
+    // Obtener los juegos en los que aparece el Pokémon
+    console.log('Games:', pokemonData.game_indices
+      .map((game) => game.version.name)
+      .join(', '));
+  } catch (error) {
+    console.error('Failed to fetch Pokémon data. Error:', error.message);
+  }
+}
+
+fetchPokemonData('pikachu');

2024/21-callbacks/README.md

@@ -0,0 +1,18 @@
+# Reto 21: Callbacks
+
+## Enunciado
+
+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.

2024/21-callbacks/index.js

@@ -0,0 +1,48 @@
+/* eslint-disable no-console */
+function processNumber(number, callback) {
+  const result = number * number;
+  callback(result);
+}
+
+function printResult(result) {
+  // eslint-disable-next-line no-console
+  console.log('El resultado es:', result);
+}
+
+// Usando la función con el callback
+processNumber(5, printResult);
+
+// DIFICULTAD
+function processOrder(dish, onConfirmation, onReady, onDelivered) {
+  // Imprimir confirmación cuando empiece el procesamiento
+  onConfirmation(dish);
+
+  // Simular un tiempo aleatorio entre 1 a 10 segundos para cada etapa del proceso
+  const randomDelay = () => Math.floor(Math.random() * 10000) + 1000;
+
+  // Simular la confirmación del pedido
+  setTimeout(() => {
+    onReady(dish); // Notificar que el plato está listo
+
+    // Simular la entrega del pedido
+    setTimeout(() => {
+      onDelivered(dish); // Notificar que el pedido ha sido entregado
+    }, randomDelay());
+  }, randomDelay());
+}
+
+// Callbacks para manejar las etapas del pedido
+function confirmOrder(dish) {
+  console.log(`Pedido confirmado para: ${dish}`);
+}
+
+function dishReady(dish) {
+  console.log(`El plato ${dish} está listo.`);
+}
+
+function orderDelivered(dish) {
+  console.log(`El plato ${dish} ha sido entregado.`);
+}
+
+// Usando la función con los callbacks
+processOrder('Pizza Margherita', confirmOrder, dishReady, orderDelivered);

2024/22-funciones-de-orden-superior/README.md

@@ -0,0 +1,15 @@
+# Reto 22: Funciones-de-orden-superior
+
+## Enunciado
+
+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).

2024/22-funciones-de-orden-superior/index.js

@@ -0,0 +1,52 @@
+/* eslint-disable no-console */
+// Función que acepta una función como argumento y aplica esa función a una lista de números
+function applyToList(numbers, operation) {
+  return numbers.map(operation);
+}
+
+// Función para duplicar un número
+function double(number) {
+  return number * 2;
+}
+
+// Usando la función applyToList con la función double
+const numbers = [1, 2, 3, 4];
+const doubledNumbers = applyToList(numbers, double);
+
+console.log(doubledNumbers); // [2, 4, 6, 8]
+
+// Lista de estudiantes
+const students = [
+  { name: 'Alice', birthDate: '1998-06-15', grades: [9.5, 8.7, 9.1] },
+  { name: 'Bob', birthDate: '2000-01-22', grades: [6.5, 7.0, 8.2] },
+  { name: 'Charlie', birthDate: '1999-11-30', grades: [9.2, 9.8, 10.0] },
+  { name: 'Diana', birthDate: '2001-04-10', grades: [8.5, 9.0, 9.3] },
+];
+
+// 1. Promedio de calificaciones
+const averageGrades = students.map((student) => {
+  const average = student.grades
+    .reduce((acc, grade) => acc + grade, 0) / student.grades.length;
+  return { name: student.name, average };
+});
+
+// 2. Mejores estudiantes (con promedio >= 9)
+const bestStudents = averageGrades
+  .filter((student) => student.average >= 9).map((student) => student.name);
+
+// 3. Estudiantes ordenados por fecha de nacimiento (más jóvenes primero)
+const sortedByBirthDate = students
+  .slice()
+  .sort((a, b) => new Date(b.birthDate) - new Date(a.birthDate));
+
+// 4. Mayor calificación
+const highestGrade = Math.max(...students.flatMap((student) => student.grades));
+
+// Mostrar resultados
+console.log('Promedio de Calificaciones:', averageGrades);
+console.log('Mejores Estudiantes:', bestStudents);
+console.log(
+  'Estudiantes Ordenados por Fecha de Nacimiento:',
+  sortedByBirthDate.map((student) => student.name),
+);
+console.log('Mayor Calificación:', highestGrade);

2024/23-singleton/README.md

@@ -0,0 +1,11 @@
+# Reto 23: Singleton
+
+## Enunciado
+
+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.