Añade soluciones a los ejercicios medios de Javascript

Author: José Miguel Sánchez Alés

source/99.ejercicios/soluciones/JS/ejM02.js

@@ -37,9 +37,9 @@ function generarAleatorio(min, max) {
  * 
  * @param {number} n - Número de dados en la tirada
  * 
- * @yields {Array} - La puntuación de cada dado.
+ * @yields {number} - La puntuación de cada dado.
  */
-function* generarTirada(n) {
+function* generarPartida(n) {
     let tirada;
 
     if(!Number.isInteger(n) || n < 1) {
@@ -57,12 +57,12 @@ function* generarTirada(n) {
 
 // Programa principal
 
-const partida = generarTirada(numDados);
-let dados, intentos = 0;
+const partida = generarPartida(numDados);
+let tirada, intentos = 0;
 
-for(dados of partida) {
+for(tirada of partida) {
     intentos++;
-    console.log(`Resultado de la ${intentos}ª tirada: ${dados}.`);
+    console.log(`Resultado de la ${intentos}ª tirada: ${tirada.join("-")}.`);
 }
 
-console.log(`Se han tardado ${intentos} tandas en sacar todo ${dados[0]} simultáneamente.`);
+console.log(`Se han tardado ${intentos} tiradas en sacar ${tirada.join("-")}.`);

source/99.ejercicios/soluciones/JS/ejM03.js

@@ -0,0 +1,60 @@
+/**
+ * @file Obtener a partir de un número el resultante de invertir
+ * todas sus cifras.
+ * @author José Miguel Sánchez Alés <jsanale860@g.educaand.es>
+ */
+
+/**
+ * Controla si se genera una entrada alteatoria o no.
+ * @type {boolean}
+ */
+const aleatorio = true;
+
+/**
+ * Límite inferior predefinido para generar aleatorios.
+ * @type {number}
+ */
+const MIN = 10,
+/**
+ * Límite superior predefinido para generar aleatorios.
+ * @type {number}
+ */
+      MAX = 9999999;
+
+/**
+ * Número predeterminado
+ * @type {number}
+ */
+const NUMERO = 123;
+
+
+/**
+ * Genera un entero aleatorio entre un límite inferior
+ * y un límite superior
+ *
+ * @param {number} min - El límite inferior.
+ * @param {number} max - El límite superior.
+ * 
+ * @example
+ * generarAleatorio(0, 10); // Entero entre 0 y 10 (ambos inclusive)
+ * 
+ * @returns {number} - El entero aleatorio.
+ */
+function generarAleatorio(min, max) {
+    return Math.round(Math.random()*(max - min)) + min;
+}
+
+/**
+ * Calcula el número resultante de invertir de orden
+ * las cifras del número original.
+ * @param {number} n - El número original.
+ * 
+ * @returns {number} - El número invertido.
+ */
+function invertirNumero(n) {
+    return Number(Array.from(String(n)).reverse().join(''));
+}
+
+
+const numero = aleatorio?generarAleatorio(MIN, MAX):NUMERO;
+console.log(`La inversión de ${numero} es ${invertirNumero(numero)}.`);

source/99.ejercicios/soluciones/JS/ejM06.js

@@ -5,15 +5,21 @@
 
 /**
  * Calibres existentes.
- * @type {Array}
+ * @type {String[]}
  */
 const CALIBRES = ["1", "2", "3"],
 /**
  * Tipos de uva.
- * @type {Array}
+ * @type {String[]}
  */
       VARIEDADES = ["tempranillo", "palomino", "moscatel"];
 
+/**
+ * Precisión de la moneda.
+ * @type {number}
+ */
+const precision = 2;
+
 /**
  * Genera un número aleatorio entre un límite inferior
  * y un límite superior
@@ -32,26 +38,53 @@ function generarAleatorio(min, max) {
  * En un programa serio posiblemente debería leerse la entrada desde
  * un documento JSON.
  * 
- * @return {Object} - Los precios y cantidades de cada uva.
+ * La entrada tendrá el siguiente formato:
+ * 
+ * [
+ *    {
+ *       variedad: "tempranillo",
+ *       calibres: [
+ *          {
+ *             nombre: "1",
+ *             precio: 1.24,
+ *             cantidad: 100
+ *          },
+ *          {
+ *              nombre: "3",
+ *              precio: 1.89,
+ *              cantidad: 67
+ *          }
+ *       ]
+ *    },
+ *    {
+ *       variedad: "palomino",
+ *       calibres: [
+ *         ... como arriba ...
+ *       ]
+ *    }
+ * ]
+ * 
+ * @return {Object[]} - Los precios y cantidades de cada uva.
  */
 function obtenerEntrada() {
     const precioRef = .75,
-          rangoCorrUva = [.5, 2],        // Factor corrector del precio según la variedad.
-          rangoCorrCalibre = [1.2, 1.8], // Multiplicador del precio del calibre.
-          noHayUva = .3,                 // Probabilidad de que no haya uva de un calibre determinado.
-          rangoCantidad = [0, 30];       // Entre 0 y 30 Kg de cada calibre de uva.
+          rangoCorrUva = [.5, 2],         // Factor corrector del precio según la variedad.
+          rangoCorrCalibre = [1.2, 1.8],  // Multiplicador del precio del calibre.
+          noHayUva = .3,                  // Probabilidad de que no haya uva de un calibre determinado.
+          rangoCantidad = [50, 500],      // Entre 50 y 500 Kg de cada calibre de uva.
+          precisionCantidad = 3;
 
     return VARIEDADES.map(variedad => {
         const uva = {nombre: variedad, calibres: []};
-        let precio = (precioRef*generarAleatorio(...rangoCorrUva)).toFixed(2);
+        let precio = (precioRef*generarAleatorio(...rangoCorrUva)).toFixed(precision);
 
         for(const calibre of CALIBRES) {
             if(Math.random() < noHayUva) continue;
 
             uva.calibres.push({
                 nombre: calibre,
                 precio,
-                cantidad: generarAleatorio(...rangoCantidad).toFixed(3)
+                cantidad: generarAleatorio(...rangoCantidad).toFixed(precisionCantidad)
             })
 
             precio = (precio*generarAleatorio(...rangoCorrCalibre)).toFixed(2);
@@ -61,6 +94,20 @@ function obtenerEntrada() {
     });
 }
 
-// Falta terminarlo.
 
-console.log(obtenerEntrada().map(e => e.calibres));
+/**
+ * Calcula el precio que hay que pagar a una determinada cosecha de uvas.
+ * 
+ * @param {Object[]} cosecha - Cantidas y precios de cada variedad y calibre.
+ * 
+ * @returns {number} - El dinero que debe pagarse a la cosecha.
+ */
+function calcularPago(cosecha) {
+    return cosecha.reduce((ac, variedad) => ac + variedad.calibres.reduce((acc, e) => acc + e.precio*e.cantidad, 0), 0)
+        .toFixed(precision);
+}
+
+const uvaCosechada = obtenerEntrada();
+
+console.log(uvaCosechada.map(e => e.calibres));
+console.log(calcularPago(uvaCosechada));

source/99.ejercicios/soluciones/JS/ejM07.js

@@ -0,0 +1,115 @@
+/**
+ * @file Obtener a partir de un número el resultante de invertir
+ * todas sus cifras.
+ * @author José Miguel Sánchez Alés <jsanale860@g.educaand.es>
+ */
+
+/**
+ * Controla si se genera una entrada alteatoria o no.
+ * @type {boolean}
+ */
+const aleatorio = true;
+
+/**
+ * Mayoría de edad
+ * @type  {number}
+ */
+const MAYORIA = 18;
+
+/**
+ * Fecha más antigua para generar fechas aleatorias.
+ * @type {number}
+ */
+const MIN = new Date(1925, 1, 1),
+/**
+ * Fecha más reciente para generar fechas aleatorias.
+ * @type {number}
+ */
+      MAX = new Date();  // hoy.
+
+/**
+ * Fechas predeterminadas.
+ * @type {number}
+ */
+const FECHAS = [
+    new Date(1967, 12, 1),
+    new Date(2000, 3, 8),
+    new Date(2010, 10, 11)
+];
+
+
+/**
+ * Genera un entero aleatorio entre un límite inferior
+ * y un límite superior
+ *
+ * @param {number} min - El límite inferior.
+ * @param {number} max - El límite superior.
+ * 
+ * @example
+ * generarAleatorio(0, 10); // Entero entre 0 y 10 (ambos inclusive)
+ * 
+ * @returns {number} - El entero aleatorio.
+ */
+function generarAleatorio(min, max) {
+    return Math.round(Math.random()*(max - min)) + min;
+}
+
+/**
+ * Función generadora de fechas al azar entre dos fechas.
+ * 
+ * @param {Date} min - Fecha más antigua. Tiempo 0 de la época UNIX, si no se especifica.
+ * @param {Date} max - Fecha más reciente. Hoy, si no se especifica.
+ * 
+ * @yields {Date} - La fecha al azar entre los dos límites suministrados.
+ */
+function* generarFecha(min = new Date(0), max = new Date()) {
+    while(true) {
+        yield new Date(generarAleatorio(min.getTime(), max.getTime()));
+    }
+}
+
+
+/**
+ * Calcula cuál es la edad en años.
+ * 
+ * @param {Date} nacimiento - Fecha de nacimiento.
+ * @param {Date} ref - Fecha de referencia para calcular la edad. Si no se especifica, hoy.
+ * 
+ * @returns {number} - La edad en años; -1 si la fecha de referencia es posterior al nacimiento.
+ */
+function calcularEdad(nacimiento, ref = new Date()) {
+    if(ref < nacimiento) return -1;
+
+    let edad = ref.getFullYear() - nacimiento.getFullYear();
+
+    // Pero si aún no ha sido su cumpleaños, tiene uno menos.
+    edad -= (nacimiento.getMonth() > ref.getMonth() || nacimiento.getMonth() === ref.getMonth() &&  nacimiento.getDate() > ref.getDate());
+
+    return edad;
+}
+
+/**
+ * Determina si una persona es mayor de edad.
+ * 
+ * @param {number|Date} nacimiento - Fecha de nacimiento o edad en años de la persona.
+ * 
+ * @returns {boolean} - Si es o no mayor de edad.
+ */
+function esMayorDeEdad(nacimiento) {
+    const edad = (nacimiento instanceof Date)?calcularEdad(nacimiento):nacimiento;
+
+    return edad >= MAYORIA;
+}
+
+
+// Programa principal.
+
+const generador = generarFecha(MIN, MAX),
+      fechas = aleatorio?FECHAS.map(e => generador.next().value):FECHAS;
+
+for(const nacimiento of fechas) {
+    let edad = calcularEdad(nacimiento),
+        yymmdd = nacimiento.toJSON().slice(0, 10);
+
+    console.log(`La persona nacida en ${yymmdd} tiene ${edad} años y es ${esMayorDeEdad(edad)?"mayor":"menor"} de edad.`);
+}

source/99.ejercicios/soluciones/JS/ejM08.js

@@ -0,0 +1,57 @@
+"use strict";
+
+/**
+ * @file Excluir los números menores al último.
+ * @author José Miguel Sánchez Alés <jsanale860@g.educaand.es>
+ */
+
+/**
+ * Controla si se genera una entrada alteatoria o no.
+ * @type {boolean}
+ */
+const aleatorio = true;
+
+/**
+ * Límite inferior predefinido para generar aleatorios.
+ * @type {number}
+ */
+const MIN = 0,
+    /**
+     * Límite superior predefinido para generar aleatorios.
+     * @type {number}
+     */
+    MAX = 100;
+
+/**
+ * Lista predeterminada
+ * @type {Number[]}
+ */
+const LISTA = [87, 22, 45, 78, 33, 64, 1, 66, 21, 56];
+
+/**
+ * Genera un entero aleatorio entre un límite inferior
+ * y un límite superior
+ *
+ * @param {number} min - El límite inferior.
+ * @param {number} max - El límite superior.
+ * 
+ * @example
+ * // Devuelve un entero entre 0 y 10 (ambos inclusive)
+ * generarAleatorio(0, 10);
+ * 
+ * @returns {number} - El entero aleatorio.
+ */
+function generarAleatorio(min, max) {
+    return Math.round(Math.random() * (max - min)) + min;
+}
+
+// Programa principal
+
+const lista = aleatorio?LISTA.map(e => generarAleatorio(MIN, MAX)):LISTA;
+
+// Como eliminar los números menores al último
+// no es algo a priori que sea útil en distintas situaciones,
+// no me molestaré ni en hacer una función.
+
+console.log(`Lista: [${lista}].`);
+console.log(`Menores: [${lista.filter((e, _, arr) => e <= arr.at(-1))}]`);