Añade algunas resoluciones de ejercicios sobre Javascript

Author: José Miguel Sánchez Alés

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

@@ -0,0 +1,68 @@
+/**
+ * @file Realiza tiradas de dos dados hasta que en una misma tirada
+ * los dos dados sacan la misma puntuación.
+ * @author José Miguel Sánchez Alés <jsanale860@g.educaand.es>
+ */
+
+/**
+ * Número de datos lanzados en una tirada.
+ * @type {number}
+ */
+const numDados = 2,
+/**
+ * Número de caras de cada dado.
+ * @type {number}
+ */
+      numCaras = 6;
+
+/**
+ * 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;
+}
+
+
+/**
+ * Lanza n dados hasta que todas las puntuaciones de un misma tirada sean iguales.
+ * 
+ * @param {number} n - Número de dados en la tirada
+ * 
+ * @yields {Array} - La puntuación de cada dado.
+ */
+function* generarTirada(n) {
+    let tirada;
+
+    if(!Number.isInteger(n) || n < 1) {
+        throw "Debe tirarse al menos un dado";
+    }
+
+    // Las tiradas continúan mientras todas
+    // las puntuaciones de una misma tirada no sean iguales.
+    do {
+        // Una tirada son "n" puntuaciones de dados
+        tirada = Array(n).fill(null).map(e => generarAleatorio(1, numCaras));
+        yield tirada;
+    } while(tirada.some((e, _, arr) => e !== arr[0]));
+}
+
+// Programa principal
+
+const partida = generarTirada(numDados);
+let dados, intentos = 0;
+
+for(dados of partida) {
+    intentos++;
+    console.log(`Resultado de la ${intentos}ª tirada: ${dados}.`);
+}
+
+console.log(`Se han tardado ${intentos} tandas en sacar todo ${dados[0]} simultáneamente.`);

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

@@ -0,0 +1,33 @@
+"use strict";
+
+/**
+ * @file Crear indexOf_N() que busque la aparición n-ésima de un determinado valor.
+ * @author José Miguel Sánchez Alés <jsanale860@g.educaand.es>
+ */
+
+
+/**
+ * Busca en un array la aparición n-ésima de un determinado valor.
+ *
+ * No es lo más eficiente, pero se ha usado una función recursiva
+ * a partir del método index_Of.
+ *
+ * @param {Array} arr - Array en que se busca.
+ * @param {any} valor - Valor buscado.
+ * @param {number} n - Número de aparición.
+ *
+ * @returns {number} - La  posición que ocupa la n-ésima aparición de valor.
+ *    NaN si no hay resultados.
+ */
+function indexOf_N(arr, valor, n) {
+    const pos = arr.indexOf(valor);
+
+    if(pos ===  -1) return NaN
+    else return pos + ((n>1)?(1 + indexOf_N(arr.slice(pos + 1), valor, n-1)):0);
+}
+
+
+const a = [0, 1, 4, 1, 2, 1, 1, 4, 5, 6];
+console.log(indexOf_N(a, "a", 4));
+console.log(indexOf_N(a, 2, 4));
+console.log(indexOf_N(a, 1, 4));

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

@@ -0,0 +1,72 @@
+/**
+ * @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 = 99999;
+
+/**
+ * Números predeterminados
+ * @type {number}
+ */
+const NUMEROS = [1452, 1221, 535, 78687, 321];
+
+
+/**
+ * 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(''));
+}
+
+/**
+ * Comprueba si un número es capicúa
+ * 
+ * @param {number} n - El número a comprobar.
+ * 
+ * @returns {boolean} - Si lo es o no.
+ */
+function esCapicua(n) {
+    return n === invertirNumero(n);
+}
+
+const numeros = aleatorio?NUMEROS.map(e => generarAleatorio(MIN, MAX)):NUMEROS;
+for(const num of numeros) {
+    console.log(`El número ${num}${esCapicua(num)?"":" no"} es capicúa.`);
+}

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

@@ -0,0 +1,66 @@
+/**
+ * @file Obtener los beneficios de una venta de uvas.
+ * @author José Miguel Sánchez Alés <jsanale860@g.educaand.es>
+ */
+
+/**
+ * Calibres existentes.
+ * @type {Array}
+ */
+const CALIBRES = ["1", "2", "3"],
+/**
+ * Tipos de uva.
+ * @type {Array}
+ */
+      VARIEDADES = ["tempranillo", "palomino", "moscatel"];
+
+/**
+ * Genera un número 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.
+ * 
+ * @returns {number} - El número aleatorio.
+ */
+function generarAleatorio(min, max) {
+    return Math.random()*(max - min) + min;
+}
+
+/**
+ * Genera los precios y las cantidades de uva de forma aleatoria.
+ * En un programa serio posiblemente debería leerse la entrada desde
+ * un documento JSON.
+ * 
+ * @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.
+
+    return VARIEDADES.map(variedad => {
+        const uva = {nombre: variedad, calibres: []};
+        let precio = (precioRef*generarAleatorio(...rangoCorrUva)).toFixed(2);
+        
+        for(const calibre of CALIBRES) {
+            if(Math.random() < noHayUva) continue;
+
+            uva.calibres.push({
+                nombre: calibre,
+                precio,
+                cantidad: generarAleatorio(...rangoCantidad).toFixed(3)
+            })
+
+            precio = (precio*generarAleatorio(...rangoCorrCalibre)).toFixed(2);
+        }
+
+        return uva;
+    });
+}
+
+// Falta terminarlo.
+
+console.log(obtenerEntrada().map(e => e.calibres));

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

@@ -55,19 +55,21 @@ function generarAleatorio(min, max) {
  * @returns {Array} - Un array con [h, m, s]
  */
 function conversorTiempo(t) {
-    const res = [t, 0, 0];
+    const res = [t, 0, 0],
+          factor = 60; // 1min tiene 60s; 1 hora, 60min
 
+    // La fracción inferior es el resto de la división;
+    // y la fracción siguiente, la división entera.
     for(let i=0; i < res.length - 1; i++) {
-        res[i+1] = Math.floor(res[i]/60);
-        res[i] = res[i]%60;
+        [res[i], res[i+1]] = [res[i]%factor, Math.floor(res[i]/factor)];
     }
 
+    // Preferimos [h, m, s] que [s, m, h]
     return res.reverse();
 
 }
 
 const tiempo = aleatorio?generarAleatorio(MIN, MAX):TIEMPO;
 
 let hms = conversorTiempo(tiempo);
-
 console.log(`${tiempo} segundos son ${hms[0]} horas, ${hms[1]} minutos y ${hms[2]} segundos.`);

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

@@ -6,16 +6,24 @@
  */
 
 /**
- * Controla si se genera una entrada alteatoria o no.
+ * Controla si se genera una entrada aleatoria o no.
  * @type {boolean}
  */
-const aleatorio = false;
+const aleatorio = true;
 
 /**
  * Operaciones disponibles
- * @type {Array}
+ * @type {object}
  */
-const OPERACIONES = ['+', '-', '*', '/', '%']
+const OPERACIONES = {
+    "suma":  (a, b) => a + b,
+    "resta": (a, b) => a - b,
+    "producto": (a, b) => a * b,
+    "división": (a, b) => a / b,
+    // Esta no la recoge el enunciado, pero es una prueba de que es muy
+    // extender la solución a otras operaciones no exigidas por el enunciado.
+    "módulo": (a, b) => a % b
+}
 
 /**
  * Límite inferior predefinido para generar aleatorios.
@@ -57,29 +65,14 @@ function generarAleatorio(min, max) {
     return Math.round(Math.random()*(max - min)) + min;
 }
 
+// Operandos
 const a = aleatorio?generarAleatorio(MIN, MAX):A,
       b =  aleatorio?generarAleatorio(MIN, MAX):B;
 
-const operacion = OPERACIONES[generarAleatorio(0, OPERACIONES.length - 1)];
-
-let resultado;
+// Escogemos una operación al azar entre las posibles.
+const opArray = Object.entries(OPERACIONES);
+let [nombre, operacion] = opArray[generarAleatorio(0, opArray.length - 1)];
 
-switch(operacion) {
-    case '+':
-        resultado = a + b;
-        break;
-    case '-':
-        resultado = a - b;
-        break;
-    case '*':
-        resultado = a * b;
-        break;
-    case '/':
-        resultado = a / b;
-        break;
-    case '%':
-        resultado  = a % b;
-        break;
-}
+let resultado = operacion(a, b);
 
-console.log(`El resultado de ${a} ${operacion} ${b} es ${resultado}`);
+console.log(`La operación ${nombre} de ${a} y ${b} es ${resultado}.`);

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

@@ -60,12 +60,12 @@ const DESCRIPTIVAS = {
 }
 
 const nota = aleatorio?generarAleatorio(MIN, MAX):NOTA,
-      // Convertimos a [descr, lím. inf] y nos quedamos sólo con las tuplas
-      // cuyo límite es más pequeño que la nota. Si las ordenamos, la tupla
+      // Convertimos a [descr, lím. inf] y eliminamos las tuplas
+      // cuyo límite es mayor que la nota. Si las ordenamos, la tupla
       // que contiene la nota descriptiva es la última, ya que es la que
       // contiene el mayor de los límites.
       notaDescriptiva = Object.entries(DESCRIPTIVAS)
-                              .filter(e => e[1] < nota)
+                              .filter(e => e[1] <= nota)
                               .sort(e => e[1]).at(-1)[0];
 
-console.log(`Un ${nota} equivale a ${notaDescriptiva}.`);
+console.log(`Un ${nota} equivale a ${notaDescriptiva}.`);