Merge pull request #7506 from Kenysdev/36_40.js

#36 - javascript -> #40

Author: kontroldev

Roadmap/36 - EL SOMBRERO SELECCIONADOR/javascript/kenysdev.js

@@ -0,0 +1,127 @@
+/*
+_____________________________________
+https://github.com/kenysdev
+2024 - JavaScript
+_______________________________________________________
+# 36 EL SOMBRERO SELECCIONADOR
+-------------------------------------------------------
+* 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).
+*/
+// ________________________________________________________
+
+const readline = require("readline");
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+const getInput = (prompt) => {
+  return new Promise((resolve) => {
+    rl.question(prompt, (input) => {
+      resolve(input.trim());
+    });
+  });
+};
+
+const HOUSES = ["Frontend", "Backend", "Mobile", "Data"];
+
+const QUESTIONS = [
+  "¿Qué te atrae más?",
+  "¿Qué superhéroe de la programación te gustaría ser?",
+  "En un proyecto de software, ¿qué rol te emociona más?",
+  "Si tu código fuera una obra de arte, ¿qué estilo tendría?",
+  "¿Qué animal de programación serías?",
+  "En una hackathon, ¿qué tipo de proyecto propondrías?",
+  "Si tu carrera en tech fuera una película, ¿de qué género sería?",
+  "¿Qué herramienta de programación no puede faltar en tu caja de herramientas digital?",
+  "Si pudieras resolver un gran problema en tech, ¿cuál elegirías?",
+  "¿Qué tipo de equipo prefieres?",
+];
+
+const ANSWERS = [
+  ["Crear experiencias visuales.", "Solucionar problemas de funcionamiento.", "Innovar en dispositivos portátiles.", "Descubrir tendencias ocultas."],
+  ["Diseñador de Interfaces, creando experiencias asombrosas", "Arquitecto de Sistemas, construyendo estructuras robustas", "Mago de Apps, conjurando soluciones móviles", "Explorador de Datos, descubriendo tesoros ocultos"],
+  ["Director de UX, orquestando la sinfonía visual", "Ingeniero de Backend, dominando la lógica del servidor", "Desarrollador de Apps, llevando la potencia al bolsillo", "Científico de Datos, descifrando los secretos de la información"],
+  ["Minimalismo elegante, como una landing page perfecta", "Arquitectura compleja, como un sistema distribuido", "Diseño adaptativo, fluyendo en diferentes dispositivos", "Visualización de datos, pintando historias con números"],
+  ["Un camaleón, adaptándome a diferentes frameworks", "Un pulpo, manejando múltiples servicios a la vez", "Un colibrí, ágil y siempre en movimiento", "Una lechuza, analizando datos con sabiduría"],
+  ["Una web app que revolucione la experiencia del usuario", "Un sistema de IA que optimice procesos backend", "Una app móvil que cambie la forma de interactuar con el mundo", "Un proyecto de big data que prediga tendencias futuras"],
+  ["Comedia romántica con JavaScript y CSS", "Thriller de ciencia ficción con microservicios", "Aventura de acción en el mundo de las apps", "Documental profundo sobre el universo de los datos"],
+  ["Un editor de código con plugins para diseño visual", "Una robusta suite de testing y depuración", "Un emulador multi-dispositivo de última generación", "Una plataforma de análisis de datos en tiempo real"],
+  ["Hacer que la accesibilidad web sea universal", "Crear una arquitectura de software autorreparable", "Desarrollar una plataforma de AR/VR para educación móvil", "Construir un modelo de IA ético y transparente"],
+  ["Creativos enfocados en diseño.", "Técnicos que construyen sistemas.", "Especialistas en aplicaciones móviles.", "Expertos en datos y análisis."],
+];
+
+class SortingHat {
+  constructor(name) {
+    this.name = name;
+    this.scores = HOUSES.reduce((acc, house) => {
+      acc[house] = 0;
+      return acc;
+    }, {});
+  }
+
+  async askQuestion(qNum, question, answers) {
+    console.log(`\n#${qNum}: ${question}`);
+    answers.forEach((answer, index) => {
+      console.log(`${index + 1}) ${answer}`);
+    });
+
+    while (true) {
+      const input = await getInput("Elige tu respuesta (1-4): ");
+      const choice = parseInt(input, 10) - 1;
+
+      if (!isNaN(choice) && choice >= 0 && choice < HOUSES.length) {
+        this.scores[HOUSES[choice]] += 1;
+        break;
+      } else {
+        console.log("Por favor, elige un número entre 1 y 4.");
+      }
+    }
+  }
+
+  selectHouse() {
+    const maxScore = Math.max(...Object.values(this.scores));
+    const topHouses = Object.keys(this.scores).filter(
+      (house) => this.scores[house] === maxScore
+    );
+
+    if (topHouses.length > 1) {
+      console.log("\nLa decisión ha sido complicada.");
+      return topHouses[Math.floor(Math.random() * topHouses.length)];
+    }
+
+    return topHouses[0];
+  }
+}
+
+const main = async () => {
+  console.log("EL SOMBRERO SELECCIONADOR");
+  const name = await getInput("¿Cuál es tu nombre? : ");
+  const hat = new SortingHat(name);
+
+  for (let i = 0; i < QUESTIONS.length; i++) {
+    await hat.askQuestion(i + 1, QUESTIONS[i], ANSWERS[i]);
+  }
+
+  const selectedHouse = hat.selectHouse();
+  console.log(`\n'${name}' pertenecerá a la casa '${selectedHouse}'\n`);
+  rl.close();
+};
+
+main();

Roadmap/37 - OASIS VS LINKIN PARK/javascript/kenysdev.js

@@ -0,0 +1,230 @@
+/*
+_____________________________________
+https://github.com/kenysdev
+2024 - JavaScript
+_______________________________________________________
+#37 OASIS VS LINKIN PARK
+-------------------------------------------------------
+* ¡Dos de las bandas más grandes de la historia están de vuelta!
+* Oasis y Linkin Park han anunciado nueva gira, pero, ¿quién es más popular?
+* 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.
+*/
+// ________________________________________________________
+require('dotenv').config();
+const https = require('https');
+
+const SPOTIFY_CLIENT_ID = process.env.SPOTIFY_CLIENT_ID;
+const SPOTIFY_CLIENT_SECRET = process.env.SPOTIFY_CLIENT_SECRET;
+
+const getSpotifyAccessToken = async () => {
+  const options = {
+    hostname: "accounts.spotify.com",
+    path: "/api/token",
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Authorization: `Basic ${Buffer.from(
+        `${SPOTIFY_CLIENT_ID}:${SPOTIFY_CLIENT_SECRET}`
+      ).toString("base64")}`,
+    },
+  };
+
+  return new Promise((resolve, reject) => {
+    const req = https.request(options, (res) => {
+      let data = "";
+
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+
+      res.on("end", () => {
+        const response = JSON.parse(data);
+        resolve(response.access_token);
+      });
+    });
+
+    req.on("error", (e) => {
+      reject(e);
+    });
+
+    req.write("grant_type=client_credentials");
+    req.end();
+  });
+};
+
+const spotifyAPIRequest = async (endpoint, accessToken) => {
+  const options = {
+    hostname: "api.spotify.com",
+    path: endpoint,
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+    },
+  };
+
+  return new Promise((resolve, reject) => {
+    const req = https.request(options, (res) => {
+      let data = "";
+
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+
+      res.on("end", () => {
+        resolve(JSON.parse(data));
+      });
+    });
+
+    req.on("error", (e) => {
+      reject(e);
+    });
+
+    req.end();
+  });
+};
+
+class Spotify {
+  constructor() {
+    this.accessToken = null;
+  }
+
+  async authenticate() {
+    this.accessToken = await getSpotifyAccessToken();
+  }
+
+  async getArtists(name) {
+    const results = await spotifyAPIRequest(
+      `/v1/search?q=artist:${encodeURIComponent(name)}&type=artist&limit=3`,
+      this.accessToken
+    );
+    return results.artists ? results.artists.items : [];
+  }
+
+  async getMostPopularArtist(name) {
+    const artists = await this.getArtists(name);
+    if (artists.length === 0) return null;
+
+    return artists.sort((a, b) => b.popularity - a.popularity)[0];
+  }
+
+  async artistTopTracks(artistId) {
+    const results = await spotifyAPIRequest(
+      `/v1/artists/${artistId}/top-tracks?market=US`,
+      this.accessToken
+    );
+    return results.tracks || [];
+  }
+
+  async artistAlbums(artistId) {
+    const results = await spotifyAPIRequest(
+      `/v1/artists/${artistId}/albums?album_type=album`,
+      this.accessToken
+    );
+    return results.items || [];
+  }
+}
+
+// Clase Versus
+class Versus {
+  constructor(artist1, artist2, spotifyInstance) {
+    this.a1 = artist1;
+    this.a2 = artist2;
+    this.sp = spotifyInstance;
+    this.a1Score = 0;
+    this.a2Score = 0;
+  }
+
+  popularity() {
+    console.log(`Popularidad: ${this.a1.popularity} vs ${this.a2.popularity}`);
+    if (this.a1.popularity > this.a2.popularity) this.a1Score++;
+    else if (this.a2.popularity > this.a1.popularity) this.a2Score++;
+  }
+
+  followers() {
+    console.log(
+      `Seguidores: ${this.a1.followers.total} vs ${this.a2.followers.total}`
+    );
+    if (this.a1.followers.total > this.a2.followers.total) this.a1Score++;
+    else if (this.a2.followers.total > this.a1.followers.total) this.a2Score++;
+  }
+
+  async top3Tracks() {
+    const a1Tracks = await this.sp.artistTopTracks(this.a1.id);
+    const a2Tracks = await this.sp.artistTopTracks(this.a2.id);
+
+    const a1Popularity = a1Tracks.slice(0, 3).reduce((sum, track) => sum + track.popularity, 0);
+    const a2Popularity = a2Tracks.slice(0, 3).reduce((sum, track) => sum + track.popularity, 0);
+
+    console.log(`Popularidad Top 3 canciones: ${a1Popularity} vs ${a2Popularity}`);
+    if (a1Popularity > a2Popularity) this.a1Score++;
+    else if (a2Popularity > a1Popularity) this.a2Score++;
+  }
+
+  async albumsAndActiveYears() {
+    const a1Albums = await this.sp.artistAlbums(this.a1.id);
+    const a2Albums = await this.sp.artistAlbums(this.a2.id);
+
+    console.log(`Número de álbumes: ${a1Albums.length} vs ${a2Albums.length}`);
+    if (a1Albums.length > a2Albums.length) this.a1Score++;
+    else if (a2Albums.length > a1Albums.length) this.a2Score++;
+
+    const a1Years = new Set(a1Albums.map((album) => album.release_date.slice(0, 4)));
+    const a2Years = new Set(a2Albums.map((album) => album.release_date.slice(0, 4)));
+
+    console.log(`Años activos: ${a1Years.size} vs ${a2Years.size}`);
+    if (a1Years.size > a2Years.size) this.a1Score++;
+    else if (a2Years.size > a1Years.size) this.a2Score++;
+  }
+
+  finalResult() {
+    console.log("\nRESULTADO FINAL:");
+    console.log(`${this.a1.name}: ${this.a1Score} puntos`);
+    console.log(`${this.a2.name}: ${this.a2Score} puntos`);
+
+    if (this.a1Score > this.a2Score) {
+      console.log(`\n¡'${this.a1.name}' gana el versus!`);
+    } else if (this.a2Score > this.a1Score) {
+      console.log(`\n¡'${this.a2.name}' gana el versus!`);
+    } else {
+      console.log("\n¡Es un empate!");
+    }
+  }
+
+  async start() {
+    console.log(`${this.a1.name} vs ${this.a2.name}`);
+    this.popularity();
+    this.followers();
+    await this.top3Tracks();
+    await this.albumsAndActiveYears();
+    this.finalResult();
+  }
+}
+
+const main = async () => {
+  const spotify = new Spotify();
+  await spotify.authenticate();
+
+  const artist1 = await spotify.getMostPopularArtist("Oasis");
+  const artist2 = await spotify.getMostPopularArtist("Linkin Park");
+
+  if (!artist1 || !artist2) {
+    console.log("Artistas no encontrados");
+    return;
+  }
+
+  const versus = new Versus(artist1, artist2, spotify);
+  await versus.start();
+};
+
+main();