Ejercicios del #23 al #24 - JavaScript

soluciones-javascript/01-fizzbuzz/app.js

@@ -0,0 +1,29 @@
+/*
+ *#1 EL FAMOSO "FIZZ BUZZ"*
+ ***
+ * Escribe un programa que muestre por consola (con un print) los
+ * números de 1 a 100 (ambos incluidos y con un salto de línea entre
+ * cada impresión), sustituyendo los siguientes:
+ * - Múltiplos de 3 por la palabra "fizz".
+ * - Múltiplos de 5 por la palabra "buzz".
+ * - Múltiplos de 3 y de 5 a la vez por la palabra "fizzbuzz".
+ */
+const fizzBuzz = () => {
+
+    for (let i = 1; i <= 100; i++) {
+
+        if(i % 3 === 0 && i % 5 === 0){
+            console.log("fizzbuzz");
+        }else if (i % 3 === 0) {
+            console.log("fizz");
+        }else if( i % 5 === 0){
+            console.log("buzz");
+        }else{
+            console.log(i);
+        }
+
+    }
+
+}
+
+fizzBuzz();

soluciones-javascript/02-anagrama/app.js

@@ -0,0 +1,40 @@
+/*
+ * Escribe una función que reciba dos palabras (String) y retorne
+ * verdadero o falso (Bool) según sean o no anagramas.
+ * - Un Anagrama consiste en formar una palabra reordenando TODAS
+ *   las letras de otra palabra inicial.
+ * - NO hace falta comprobar que ambas palabras existan.
+ * - Dos palabras exactamente iguales no son anagrama.
+ */
+
+const isAnagram = (string1 = '', string2 = '') => {
+
+    //Si algún String está vacío retorna false
+    if(!string1 || !string2 ) return false; 
+
+    if(string1.length !== string2.length ) return false; 
+
+    const stringLowerCase1 = string1.toLowerCase().trim();
+    const stringLowerCase2 = string2.toLowerCase().trim();
+
+    //Si las palabras son exactamente iguales retorna false
+    if(stringLowerCase1 === stringLowerCase2) return false;
+
+    const arrayString1 = stringLowerCase1.split("").sort().join('');
+    const arrayString2 = stringLowerCase2.split("").sort().join('');
+
+    return arrayString1 === arrayString2; 
+
+}
+
+
+console.log("Es un anagrama (amor + roma): " + isAnagram("amor", "roma"));
+console.log("Es un anagrama (listen + silent): " + isAnagram("listen", "silent"));
+console.log("Es un anagrama (test + test): " + isAnagram("test", "test"));
+console.log("Es un anagrama ( + word): " + isAnagram("", "word"));
+console.log("Es un anagrama (test + testing): " + isAnagram("test", "testing"));
+console.log("Es un anagrama (Listen + Silent): " + isAnagram("Listen", "Silent"));
+console.log("Es un anagrama (Dormitory + Dirty room): " + isAnagram("Dormitory", "Dirty room"));
+
+
+

soluciones-javascript/03-fibonacci/app.js

@@ -0,0 +1,33 @@
+/*
+ * * LA SUCESIÓN DE FIBONACCI *
+ * Escribe un programa que imprima los 50 primeros números de la sucesión
+ * de Fibonacci empezando en 0.
+ * - La serie Fibonacci se compone por una sucesión de números en
+ *   la que el siguiente siempre es la suma de los dos anteriores.
+ *   0, 1, 1, 2, 3, 5, 8, 13...
+ */
+
+
+const sucesionFibonacci = ( cantidadNumeros ) => {
+
+    if ( cantidadNumeros < 0 ) return console.log(0);
+
+    let anterior = 0;
+    let actual = 1;
+
+    for (let i = 0; i < cantidadNumeros; i++) {
+
+        console.log(`${ i + 1 }_:  ${anterior}`);
+
+        let temp = anterior; 
+        anterior = actual + anterior; 
+        actual = temp; 
+
+    }
+
+
+}
+
+
+
+sucesionFibonacci( 50 );

soluciones-javascript/04-numero-primo/app.js

@@ -0,0 +1,24 @@
+/*
+ * Escribe un programa que se encargue de comprobar si un número es o no primo.
+ * Hecho esto, imprime los números primos entre 1 y 100.
+ */
+
+const esNumeroPrimo = (numero) => {
+    if (numero <= 1) return false;
+
+    if (numero === 2) return true;
+
+    for (let i = 2; i <= Math.sqrt(numero); i++) {
+        if (numero % i === 0) {
+            return false;
+        }
+    }
+
+    return true;
+};
+
+for (let i = 2; i < 100; i++) {
+    if (esNumeroPrimo(i)) {
+        console.log(i);
+    }
+}

soluciones-javascript/05-area-poligono/app.js

@@ -0,0 +1,41 @@
+/*
+ * Crea una única función (importante que sólo sea una) que sea capaz
+ * de calcular y retornar el área de un polígono.
+ * - La función recibirá por parámetro sólo UN polígono a la vez.
+ * - Los polígonos soportados serán Triángulo, Cuadrado y Rectángulo.
+ * - Imprime el cálculo del área de un polígono de cada tipo.
+ */
+
+const areaPoligono = ({ tipo = "", datosPoligono = {} }) => {
+
+    const esPositivo = (n) => typeof n === 'number' && n > 0; 
+
+    switch (tipo) {
+        case "Triangulo":
+            if ( esPositivo(datosPoligono.base) && esPositivo(datosPoligono.altura) ) {
+                return (datosPoligono.base * datosPoligono.altura) / 2;
+            }else{
+                throw new Error("Los datos del triangulo deben ser positivos");
+            }
+        case "Cuadrado":
+            if ( esPositivo(datosPoligono.lado) ) {
+                return datosPoligono.lado * datosPoligono.lado;
+            }else{
+                throw new Error("Los datos del Cuadrado deben ser positivos");
+            }    
+        case "Rectangulo": 
+            if ( esPositivo(datosPoligono.base) && esPositivo(datosPoligono.altura) ) {
+                return datosPoligono.base * datosPoligono.altura; 
+            }else{
+                throw new Error("Los datos del Rectangulo deben ser positivos");
+            }
+        default:
+            throw new Error("Especifica un dato correcto");
+    }
+
+}
+
+// Ejemplos de uso
+console.log(areaPoligono({ tipo: "Triangulo", datosPoligono: { base: 2, altura: 4 } }));
+console.log(areaPoligono({ tipo: "Cuadrado", datosPoligono: { lado: 5 } }));
+console.log(areaPoligono({ tipo: "Rectangulo", datosPoligono: { base: 3, altura: 6 } }));

soluciones-javascript/06-aspect-ratio-image/app.js

@@ -0,0 +1,43 @@
+/*
+ * Crea un programa que se encargue de calcular el aspect ratio de una
+ * imagen a partir de una url.
+ * - Url de ejemplo:
+ *   https://es.vitejs.dev/og-image-announcing-vite3.png
+ * - Por ratio hacemos referencia por ejemplo a los "16:9" de una
+ *   imagen de 1920*1080px.
+ */
+
+
+const calcularAspectRatio = async (url) => {
+
+    const img = new Image();
+
+    img.src = url;
+
+    img.onload = () => {
+        const width = img.width;
+        const height = img.height;
+
+        // Maximo comun divisor
+        const mcd = ( a, b ) => b === 0 ? a : mcd( b, a % b );
+
+        console.log(mcd(width, height));
+
+        const ratioMCD = mcd(width, height); 
+
+        console.log(`La resolución de la imagen es ${width}x${height}`);
+        console.log(`La relación de aspecto es: ${ width / ratioMCD }:${ height / ratioMCD }`);
+
+
+    }
+
+    img.onerror = () => {
+        console.error('No se pudo cargar la imagen');
+    }
+
+    return img;
+
+}
+
+const url = "https://cdn.unotv.com/images/2024/03/mazapan-perrito-influencer-143900-1024x576.jpeg"
+calcularAspectRatio(url);

soluciones-javascript/06-aspect-ratio-image/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Ejercicio de programación</title>
+</head>
+<body>
+    <script src="app.js"></script>
+</body>
+</html>

soluciones-javascript/07-inviertiendo-cadenas/app.js

@@ -0,0 +1,22 @@
+/*
+ * Crea un programa que invierta el orden de una cadena de texto
+ * sin usar funciones propias del lenguaje que lo hagan de forma automática.
+ * - Si le pasamos "Hola mundo" nos retornaría "odnum aloH"
+ */
+
+const reverseTextString = (string) => {
+
+    const stringFormatter = string.trim();
+    let reverseText = "";
+
+    for (let i = 1; i <= stringFormatter.length; i++) {
+
+        reverseText += stringFormatter[ stringFormatter.length - i];
+
+    }
+
+    return reverseText;
+
+}
+
+console.log(reverseTextString(" Hola Mundo "));

soluciones-javascript/07-inviertiendo-cadenas/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Invirtiendo cadenas</title>
+</head>
+<body>
+    <script src="app.js"></script>
+</body>
+</html>

soluciones-javascript/08-contando-palabras/app.js

@@ -0,0 +1,25 @@
+/*
+ * Crea un programa que cuente cuantas veces se repite cada palabra
+ * y que muestre el recuento final de todas ellas.
+ * - Los signos de puntuación no forman parte de la palabra.
+ * - Una palabra es la misma aunque aparezca en mayúsculas y minúsculas.
+ * - No se pueden utilizar funciones propias del lenguaje que
+ *   lo resuelvan automáticamente.
+ */
+
+const countWords = (text) => {
+    const cleanedText = text.toLowerCase().replace(/[^\w\s]/g, '');
+
+    const wordsArray = cleanedText.split(/\s+/).filter( word => word !== '');
+
+    const wordCount = {};
+    console.log({cleanedText}, {wordsArray});
+
+    wordsArray.forEach(word => {
+        wordCount[word] = (wordCount[word] || 0) + 1;
+    });
+
+    console.log( { wordsArray, wordCount } );
+};
+
+countWords(" Hola, asd  una páasdlabra d asd asd repetida,, hotra a a dsad sad palabraasd  repetida paasdq3wrlabra o hola ");

soluciones-javascript/08-contando-palabras/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Contando Palabras</title>
+</head>
+<body>
+    <h1>Abre la consola y mira el resultado</h1>
+    <script src="app.js"></script>
+</body>
+</html>

soluciones-javascript/09-decimal-binario/app.js

@@ -0,0 +1,20 @@
+/*
+ * Crea un programa se encargue de transformar un número
+ * decimal a binario sin utilizar funciones propias del lenguaje que lo hagan directamente.
+ */
+
+const decimalToBinary = (number) => {
+    let numberBinary = [];
+    let numberNew = number; 
+
+    while (numberNew > 0) {
+        numberBinary.unshift(Math.floor(numberNew % 2));
+        numberNew = Math.floor(numberNew / 2);
+    }
+
+    return numberBinary.join("");
+
+
+};
+
+console.log(decimalToBinary(10));

soluciones-javascript/09-decimal-binario/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>09 Decimal a Binario</title>
+</head>
+<body>
+    <h1>Abre la consola para ver el ejercicio</h1>
+    <script src="app.js"></script>
+</body>
+</html>

soluciones-javascript/10-codigo-morse/app.js

@@ -0,0 +1,32 @@
+/*
+ * Crea un programa que sea capaz de transformar texto natural a código
+ * morse y viceversa.
+ * - Debe detectar automáticamente de qué tipo se trata y realizar
+ *   la conversión.
+ * - En morse se soporta raya "—", punto ".", un espacio " " entre letras
+ *   o símbolos y dos espacios entre palabras "  ".
+ * - El alfabeto morse soportado será el mostrado en
+ *   https://es.wikipedia.org/wiki/Código_morse.
+ */
+
+console.log({dataMorseCode});
+
+const codigoMorse = (text) => {
+
+    return text.toUpperCase().split('').map( word => {
+
+        if(dataMorseCode[word]){
+            return dataMorseCode[word]
+        } else if (word === " "){
+            return "/";
+        }else {
+            return "";
+        }
+
+    }).join(" ");
+
+}
+
+console.log(codigoMorse("Prueba x"));
+console.log(codigoMorse("Otra prueba con diferasduhwq signficado, ayuda ´++´{}"));
+console.log(codigoMorse("Me gusta la cigueña, la malta y la inmal también jaja esxs xsxsada"));

soluciones-javascript/10-codigo-morse/dataMorseCode.js

@@ -0,0 +1,11 @@
+const dataMorseCode = {    
+    A: ".-",     B: "-...",  C: "-.-.",  D: "-..",  
+    E: ".",      F: "..-.",  G: "--.",   H: "....", 
+    I: "..",     J: ".---",  K: "-.-",   L: ".-..", 
+    M: "--",     N: "-.",    Ñ: "--.--", O: "---",  
+    P: ".--.",   Q: "--.-",  R: ".-.",   S: "...",  
+    T: "-",      U: "..-",   V: "...-",  W: ".--",  
+    X: "-..-",   Y: "-.--",  Z: "--..", 
+    '0': '-----', '1': '.----', '2': '..---', '3': '...--', '4': '....-', 
+    '5': '.....', '6': '-....', '7': '--...', '8': '---..', '9': '----.'
+};