Live Coding

¿Cómo comprobar si un objeto de JavaScript está vacío?

Explicación: Un objeto está vacío si no tiene propiedades enumerables propias. Podemos usar Object.keys(obj) que devuelve un array con los nombres de las propiedades enumerables propias de un objeto dado. Si la longitud de este array es 0, el objeto está vacío.

function isEmpty(obj) {
  return Object.keys(obj).length === 0;
}

console.log(isEmpty({})); // true
console.log(isEmpty({ a: 1 })); // false

Escribe una función para invertir una cadena de texto dada.

Explicación: La forma más sencilla es convertir la cadena en un array de caracteres, usar el método reverse() incorporado para arrays, y luego unir los caracteres de nuevo en una cadena.

function reverseString(str) {
  return str.split('').reverse().join('');
}

console.log(reverseString('hello')); // 'olleh'

Escribe una función que compruebe si una cadena dada es un palíndromo.

Explicación: Un palíndromo es una palabra o frase que se lee igual hacia adelante que hacia atrás. Podemos comprobar esto invirtiendo la cadena (ignorando mayúsculas/minúsculas y caracteres no alfanuméricos para una comprobación más robusta, pero aquí hacemos una comprobación simple) y comparándola con la original.

function isPalindrome(str) {
  const reversed = str.split('').reverse().join('');
  return str === reversed;
}

console.log(isPalindrome('racecar')); // true
console.log(isPalindrome('hello')); // false

Escribe una función para encontrar el número más grande en un array de números.

Explicación: Puedes iterar a través del array, manteniendo un registro del número más grande encontrado hasta ahora. Alternativamente, puedes usar la función Math.max() junto con la sintaxis de propagación (...) para pasar los elementos del array como argumentos.

function findMaxNumber(arr) {
  if (arr.length === 0) return undefined; // O lanzar un error
  return Math.max(...arr);
}

console.log(findMaxNumber([1, 5, 2, 9, 3])); // 9

Escribe un programa que imprima números del 1 al n. Pero para los múltiplos de tres, imprime 'Fizz' en lugar del número, y para los múltiplos de cinco, imprime 'Buzz'. Para los números que son múltiplos de tres y de cinco, imprime 'FizzBuzz'.

Explicación: Este problema clásico evalúa la lógica básica de bucles y condicionales. Necesitas iterar del 1 al n y usar el operador de módulo (%) para comprobar la divisibilidad por 3 y 5.

function fizzBuzz(n) {
  for (let i = 1; i <= n; 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(15);

Escribe una función que elimine los elementos duplicados de un array.

Explicación: Una forma moderna y concisa de lograr esto es usando un Set. Los Sets solo almacenan valores únicos. Puedes convertir el array a un Set y luego de nuevo a un array.

function removeDuplicates(arr) {
  return [...new Set(arr)];
}

console.log(removeDuplicates([1, 2, 2, 3, 4, 4, 5])); // [1, 2, 3, 4, 5]

Escribe una función para comprobar si dos cadenas son anagramas entre sí.

Explicación: Los anagramas son palabras formadas al reorganizar las letras de otra. Para comprobarlo, podemos limpiar, ordenar y comparar las cadenas. La limpieza implica eliminar caracteres no alfanuméricos y convertir a un mismo formato (mayúsculas/minúsculas).

function isAnagram(str1, str2) {
  const clean = (str) => str.replace(/[^a-z0-9]/gi, '').toLowerCase();
  const sorted = (str) => clean(str).split('').sort().join('');
  
  return sorted(str1) === sorted(str2);
}

console.log(isAnagram('listen', 'silent')); // true
console.log(isAnagram('hello', 'world')); // false

Escribe una función para calcular el factorial de un entero no negativo.

Explicación: El factorial (n!) de un número es el producto de todos los enteros positivos menores o iguales a n. Podemos calcular esto iterativamente multiplicando números del 1 hasta n.

function factorial(n) {
  if (n < 0) return undefined; // El factorial no está definido para números negativos
  if (n === 0) return 1;
  let result = 1;
  for (let i = 1; i <= n; i++) {
    result *= i;
  }
  return result;
}

console.log(factorial(5)); // 120

Escribe una función que devuelva la suma de todos los números en un array.

Explicación: Puedes usar el método reduce, que es ideal para acumular un único valor de un array. Toma una función de callback y un valor inicial (0 para la suma).

function sumArray(arr) {
  return arr.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
}

console.log(sumArray([1, 2, 3, 4])); // 10

Escribe una función para aplanar un array anidado. Para simplificar, asume solo un nivel de anidación.

Explicación: Para un solo nivel de anidación, puedes usar Array.prototype.concat() con el operador de propagación o el método flat() (ES2019).

function flattenArray(arr) {
  // Usando flat() (más simple si ES2019+ es aceptable)
  // return arr.flat();

  // Usando reduce y concat
  return arr.reduce((acc, val) => acc.concat(val), []);
}

console.log(flattenArray([1, [2, 3], 4, [5]])); // [1, 2, 3, 4, 5]

Escribe una función que cuente el número de vocales (a, e, i, o, u) en una cadena dada.

Explicación: Itera a través de la cadena (sin distinción de mayúsculas/minúsculas) y comprueba si cada carácter es una vocal. Mantén un contador.

function countVowels(str) {
  const vowels = 'aeiou';
  let count = 0;
  for (let char of str.toLowerCase()) {
    if (vowels.includes(char)) {
      count++;
    }
  }
  return count;
}

console.log(countVowels('Hello World')); // 3

Escribe una función que convierta una oración a formato de título (la primera letra de cada palabra capitalizada).

Explicación: Divide la oración en palabras, luego itera a través de cada palabra, capitalizando la primera letra y haciendo el resto minúsculas. Finalmente, une las palabras de nuevo.

function titleCase(str) {
  return str.toLowerCase().split(' ').map(word => {
    return word.charAt(0).toUpperCase() + word.slice(1);
  }).join(' ');
}

console.log(titleCase('i am a little tea pot')); // 'I Am A Little Tea Pot'

Dado un array de enteros nums y un entero target, devuelve los índices de los dos números tales que sumen target.

Explicación: Un enfoque común es usar un mapa hash (o un objeto JavaScript) para almacenar números y sus índices a medida que iteras. Para cada número, comprueba si target - numero_actual existe en el mapa.

function twoSum(nums, target) {
  const map = {};
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (map[complement] !== undefined) {
      return [map[complement], i];
    }
    map[nums[i]] = i;
  }
  return []; // O null, o lanzar error si no hay solución
}

console.log(twoSum([2, 7, 11, 15], 9)); // [0, 1]

Crea una función que devuelva una función de contador. Cada vez que se llame a la función devuelta, debe incrementar y devolver un conteo.

Explicación: Esto demuestra las clausuras. La función interna tiene acceso a la variable count del ámbito de la función externa, incluso después de que la función externa haya terminado de ejecutarse.

function createCounter() {
  let count = 0;
  return function() {
    count++;
    return count;
  };
}

const counter1 = createCounter();
console.log(counter1()); // 1
console.log(counter1()); // 2
const counter2 = createCounter();
console.log(counter2()); // 1

Escribe una función que encuentre el primer carácter no repetido en una cadena.

Explicación: Puedes usar un mapa hash para contar las frecuencias de los caracteres. Primero, itera a través de la cadena para construir el mapa de frecuencias. Luego, itera a través de la cadena nuevamente y devuelve el primer carácter con un conteo de 1.

function firstNonRepeatingChar(str) {
  const charCount = {};
  for (const char of str) {
    charCount[char] = (charCount[char] || 0) + 1;
  }
  for (const char of str) {
    if (charCount[char] === 1) {
      return char;
    }
  }
  return null; // O algún indicador si todos se repiten
}

console.log(firstNonRepeatingChar('aabbcdeeff')); // 'c'
console.log(firstNonRepeatingChar('swiss')); // 'w'

Escribe una función que divida un array en grupos de un tamaño especificado.

Explicación: Itera a través del array, tomando 'rebanadas' del tamaño especificado y empujándolas a un nuevo array. Maneja el caso en que el último segmento podría ser más pequeño.

function chunkArray(arr, size) {
  const chunked = [];
  let index = 0;
  while (index < arr.length) {
    chunked.push(arr.slice(index, index + size));
    index += size;
  }
  return chunked;
}

console.log(chunkArray([1, 2, 3, 4, 5, 6, 7], 3)); // [[1, 2, 3], [4, 5, 6], [7]]

Escribe una función para determinar si un número dado es un número primo.

Explicación: Un número primo es un número natural mayor que 1 que no tiene divisores positivos aparte del 1 y de sí mismo. Itera desde 2 hasta la raíz cuadrada del número, comprobando la divisibilidad. Maneja casos límite como 1 y 2.

function isPrime(num) {
  if (num <= 1) return false;
  if (num <= 3) return true;

  if (num % 2 === 0 || num % 3 === 0) return false;

  for (let i = 5; i * i <= num; i = i + 6) {
    if (num % i === 0 || num % (i + 2) === 0) return false;
  }

  return true;
}

console.log(isPrime(7)); // true
console.log(isPrime(10)); // false

Escribe una función que encuentre la palabra más larga en una oración.

Explicación: Divide la cadena en un array de palabras. Luego, itera a través del array, manteniendo un registro de la palabra más larga encontrada hasta ahora (o su longitud).

function findLongestWord(str) {
  const words = str.split(' ');
  let longestWord = '';
  for (const word of words) {
    // Limpiar palabras si es necesario (ej. eliminar puntuación)
    if (word.length > longestWord.length) {
      longestWord = word;
    }
  }
  return longestWord;
}

console.log(findLongestWord('The quick brown fox jumped over the lazy dog')); // 'jumped'

Implementa tu propia versión de la función Array.prototype.map.

Explicación: La función map toma una función de callback y crea un nuevo array aplicando la función de callback a cada elemento del array original. Tu función debe iterar a través del array y construir el nuevo array.

function myMap(arr, callback) {
  const mappedArray = [];
  for (let i = 0; i < arr.length; i++) {
    mappedArray.push(callback(arr[i], i, arr));
  }
  return mappedArray;
}

const numbers = [1, 4, 9];
const roots = myMap(numbers, Math.sqrt);
console.log(roots); // [1, 2, 3]

Implementa tu propia versión de la función Array.prototype.filter.

Explicación: La función filter toma una función de callback y crea un nuevo array con todos los elementos que pasan la prueba implementada por la función de callback proporcionada.

function myFilter(arr, callback) {
  const filteredArray = [];
  for (let i = 0; i < arr.length; i++) {
    if (callback(arr[i], i, arr)) {
        filteredArray.push(arr[i]);
    }
  }
  return filteredArray;
}

const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
const result = myFilter(words, word => word.length > 6);
console.log(result); // ['exuberant', 'destruction', 'present']

Implementa tu propia versión de la función Array.prototype.reduce.

Explicación: La función reduce ejecuta una función de callback 'reductora' proporcionada por el usuario en cada elemento del array, pasando el valor de retorno del cálculo del elemento precedente. El resultado final de ejecutar el reductor a través de todos los elementos del array es un único valor. Maneja el argumento del valor inicial.

function myReduce(arr, callback, initialValue) {
  let accumulator = initialValue;
  let startIndex = 0;

  if (initialValue === undefined) {
      if (arr.length === 0) throw new TypeError('Reduce de un array vacío sin valor inicial');
      accumulator = arr[0];
      startIndex = 1;
  }

  for (let i = startIndex; i < arr.length; i++) {
    accumulator = callback(accumulator, arr[i], i, arr);
  }
  return accumulator;
}

const array1 = [1, 2, 3, 4];
const sum = myReduce(array1, (acc, curr) => acc + curr, 0);
console.log(sum); // 10

Implementa una función de Fibonacci usando memoización para optimizar el rendimiento.

Explicación: La secuencia de Fibonacci implica cálculos repetidos. La memoización almacena los resultados de llamadas a funciones costosas y devuelve el resultado en caché cuando las mismas entradas ocurren nuevamente.

function memoizedFib() {
  const cache = {};

  function fib(n) {
    if (n in cache) {
      return cache[n];
    }
    if (n <= 1) {
      return n;
    }
    const result = fib(n - 1) + fib(n - 2);
    cache[n] = result;
    return result;
  }
  return fib;
}

const fibonacci = memoizedFib();
console.log(fibonacci(10)); // 55
console.log(fibonacci(40)); // 102334155 (mucho más rápido que sin memoización)

Escribe una función para comprobar si una cadena que contiene corchetes {}[]() está balanceada.

Explicación: Usa una pila (stack). Cuando encuentres un corchete de apertura, empújala a la pila. Cuando encuentres un corchete de cierre, comprueba si la pila está vacía o si el elemento superior es el corchete de apertura correspondiente. Si coincide, saca el elemento de la pila. Si no, o si la pila está vacía, está desequilibrada. Al final, una pila vacía significa que está balanceada.

function isBalanced(str) {
  const stack = [];
  const map = { '(': ')', '{': '}', '[': ']' };

  for (let char of str) {
    if (map[char]) {
      stack.push(char);
    } else if (Object.values(map).includes(char)) {
      if (stack.length === 0) return false;
      const lastOpen = stack.pop();
      if (map[lastOpen] !== char) return false;
    }
  }
  return stack.length === 0;
}

console.log(isBalanced('({[]})')); // true
console.log(isBalanced('([)]')); // false

Implementa una estructura de datos de Cola (Queue) con los métodos enqueue (añadir al final) y dequeue (eliminar del principio).

Explicación: Una cola sigue el principio FIFO (First-In, First-Out). Se puede usar un array, con push para enqueue y shift para dequeue.

class Queue {
  constructor() {
    this.items = [];
  }

  enqueue(element) {
    this.items.push(element);
  }

  dequeue() {
    if (this.isEmpty()) return 'Underflow';
    return this.items.shift();
  }

  front() {
    if (this.isEmpty()) return 'No elements in Queue';
    return this.items[0];
  }

  isEmpty() {
    return this.items.length === 0;
  }
}

const q = new Queue();
q.enqueue(10);
q.enqueue(20);
console.log(q.dequeue()); // 10
console.log(q.front()); // 20

Implementa una estructura de datos de Pila (Stack) con los métodos push (añadir a la cima) y pop (eliminar de la cima).

Explicación: Una pila sigue el principio LIFO (Last-In, First-Out). Se puede usar un array, con los métodos push y pop.

class Stack {
  constructor() {
    this.items = [];
  }

  push(element) {
    this.items.push(element);
  }

  pop() {
    if (this.isEmpty()) return 'Underflow';
    return this.items.pop();
  }

  peek() {
    return this.items[this.items.length - 1];
  }

  isEmpty() {
    return this.items.length === 0;
  }
}

const s = new Stack();
s.push(10);
s.push(20);
console.log(s.pop()); // 20
console.log(s.peek()); // 10

Dado un array que contiene n números distintos tomados de 0, 1, 2, ..., n, encuentra el que falta en el array.

Explicación: La suma de los números del 0 al n se puede calcular usando la fórmula n*(n+1)/2. La suma real de los elementos del array se puede calcular. La diferencia entre estas dos sumas será el número que falta.

function findMissingNumber(nums) {
  const n = nums.length;
  const expectedSum = n * (n + 1) / 2;
  const actualSum = nums.reduce((sum, num) => sum + num, 0);
  return expectedSum - actualSum;
}

console.log(findMissingNumber([3, 0, 1])); // 2
console.log(findMissingNumber([9, 6, 4, 2, 3, 5, 7, 0, 1])); // 8

Implementa una función debounce. Debounce asegura que una función no se llame de nuevo hasta que haya pasado una cierta cantidad de tiempo sin que se haya llamado.

Explicación: Usa setTimeout y clearTimeout. Cada vez que se llama a la función debounced, borra el timeout anterior y establece uno nuevo. La llamada a la función real solo ocurre cuando el timeout se completa.

function debounce(func, delay) {
  let timeoutId;
  return function(...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => {
      func.apply(this, args);
    }, delay);
  };
}

// Ejemplo de uso:
const sayHello = () => console.log('Hello!');
const debouncedHello = debounce(sayHello, 1000);
debouncedHello(); // Se llama después de 1 segundo (si no se vuelve a llamar)
debouncedHello(); // Reinicia el temporizador
debouncedHello(); // Reinicia el temporizador, se ejecutará 1 segundo después de esta llamada.

Implementa una función throttle. Throttle asegura que una función se llame como máximo una vez en un intervalo de tiempo especificado.

Explicación: Usa un flag para indicar si se permite una llamada. Cuando se llama, si se permite, ejecuta la función, establece el flag en falso y usa setTimeout para restablecer el flag después del intervalo.

function throttle(func, limit) {
  let inThrottle = false;
  return function(...args) {
    if (!inThrottle) {
      func.apply(this, args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}

// Ejemplo de uso:
const logScroll = () => console.log('Scrolling...');
const throttledScroll = throttle(logScroll, 1000);
// window.addEventListener('scroll', throttledScroll); // Registrará como máximo una vez por segundo.

Escribe una función que tome una función con dos argumentos y devuelva una versión currificada de la misma.

Explicación: Currying transforma una función con múltiples argumentos en una secuencia de funciones, cada una tomando un solo argumento. f(a, b) se convierte en f(a)(b).

function curry(fn) {
  return function(a) {
    return function(b) {
      return fn(a, b);
    };
  };
}

function add(a, b) {
  return a + b;
}

const curriedAdd = curry(add);
const add5 = curriedAdd(5);
console.log(add5(3)); // 8
console.log(curriedAdd(10)(20)); // 30

Escribe una función para realizar una clonación profunda de un objeto JavaScript.

Explicación: Un clon superficial copia solo las propiedades de nivel superior. Un clon profundo copia recursivamente todas las propiedades, incluyendo objetos y arrays anidados. Una forma simple (con limitaciones, por ejemplo, no maneja bien funciones, fechas, expresiones regulares) es usando JSON.parse(JSON.stringify(obj)). Un enfoque recursivo es más robusto.

function deepClone(obj) {
  // Versión simple (con limitaciones)
  try {
      return JSON.parse(JSON.stringify(obj));
  } catch (e) {
      console.error("Clonación fallida:", e);
      return null;
  }
  
  // Versión recursiva más robusta (ejemplo básico):
  /*
  if (obj === null || typeof obj !== 'object') {
      return obj;
  }
  let clone = Array.isArray(obj) ? [] : {};
  for (let key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
          clone[key] = deepClone(obj[key]);
      }
  }
  return clone;
  */
}

const original = { a: 1, b: { c: 2 } };
const cloned = deepClone(original);
cloned.b.c = 3;
console.log(original.b.c); // 2 (demuestra que es un clon profundo)
console.log(cloned.b.c); // 3

¿Cómo obtener un array de claves de un objeto?

Explicación: Usa Object.keys(obj).

function getKeys(obj) {
  return Object.keys(obj);
}
console.log(getKeys({a: 1, b: 2})); // ['a', 'b']

¿Cómo obtener un array de valores de un objeto?

Explicación: Usa Object.values(obj).

function getValues(obj) {
  return Object.values(obj);
}
console.log(getValues({a: 1, b: 2})); // [1, 2]

¿Cómo comprobar si un array contiene un valor específico?

Explicación: Usa Array.prototype.includes(value).

function checkIncludes(arr, val) {
  return arr.includes(val);
}
console.log(checkIncludes([1, 2, 3], 2)); // true

¿Cómo fusionar dos arrays en uno?

Explicación: Usa la sintaxis de propagación (...) o Array.prototype.concat().

function mergeArrays(arr1, arr2) {
  return [...arr1, ...arr2];
}
console.log(mergeArrays([1, 2], [3, 4])); // [1, 2, 3, 4]

¿A qué se refiere this en el ámbito global en un navegador?

Explicación: En el contexto de ejecución global (fuera de cualquier función), this se refiere al objeto global, que es window en los navegadores web.

console.log(this === window); // true (en un entorno de navegador)

¿A qué se refiere this cuando se usa dentro de un método de un objeto?

Explicación: Cuando una función se llama como método de un objeto, this se refiere al objeto sobre el que se llama el método.

const myObject = {
  prop: 'Hello',
  greet() {
    return this.prop;
  }
};
console.log(myObject.greet()); // 'Hello'

¿Cómo manejan las funciones flecha a this?

Explicación: Las funciones flecha no tienen su propio contexto this. En su lugar, heredan this del ámbito circundante (léxico) donde se definen.

function MyClass() {
  this.value = 42;
  setTimeout(() => {
    console.log(this.value); // Muestra 42 porque 'this' es heredado
  }, 100);
}
new MyClass();

¿Cuáles son las principales diferencias entre let, const y var?

Explicación: var tiene un ámbito de función y se eleva (hoisted). let y const tienen un ámbito de bloque y se elevan (hoisted), pero están en una 'zona muerta temporal' hasta la declaración. const debe ser inicializada y no puede ser reasignada.

function scopeTest() {
  var a = 1;
  let b = 2;
  const c = 3;
  if (true) {
    var a = 10; // Redeclara y afecta a 'a' exterior
    let b = 20; // Nueva 'b' dentro del bloque
    // const c = 30; // Sería una nueva 'c'
    console.log(a, b, c); // 10, 20, 3
  }
  console.log(a, b, c); // 10, 2, 3
}
scopeTest();

Explica qué es una Promesa en JavaScript.

Explicación: Una Promesa es un objeto que representa la eventual finalización (o falla) de una operación asíncrona y su valor resultante. Puede estar en uno de tres estados: pendiente, cumplida (fulfilled) o rechazada (rejected).

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('¡Éxito!');
    // reject('¡Error!');
  }, 1000);
});

myPromise
  .then(result => console.log(result))
  .catch(error => console.error(error));

¿Cómo simplifican async y await el trabajo con Promesas?

Explicación: async/await proporciona una sintaxis más sencilla sobre las Promesas, haciendo que el código asíncrono se vea y se comporte un poco más como código síncrono. Una función async siempre devuelve una Promesa, y await pausa la ejecución hasta que una Promesa se resuelva o rechace.

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function run() {
  console.log('Iniciando...');
  await delay(1000);
  console.log('Esperó 1 segundo.');
  await delay(500);
  console.log('Esperó otros 0.5 segundos.');
  return '¡Terminado!';
}

run().then(console.log);

¿Cómo convertir una cadena de texto a un número?

Explicación: Usa parseInt(), parseFloat() o el operador unario más (+).

const str = '123.45';
console.log(parseInt(str)); // 123
console.log(parseFloat(str)); // 123.45
console.log(+str); // 123.45

¿Cómo convertir un número a una cadena de texto?

Explicación: Usa String(), number.toString() o la concatenación de cadenas.

const num = 123;
console.log(String(num)); // '123'
console.log(num.toString()); // '123'
console.log('' + num); // '123'

¿Qué hace JSON.stringify?

Explicación: Convierte un objeto o valor de JavaScript a una cadena JSON.

const obj = { name: 'Alice', age: 30 };
const jsonString = JSON.stringify(obj);
console.log(jsonString); // '{"name":"Alice","age":30}'

¿Qué hace JSON.parse?

Explicación: Analiza una cadena JSON, construyendo el valor u objeto JavaScript descrito por la cadena.

const jsonString = '{"name":"Alice","age":30}';
const obj = JSON.parse(jsonString);
console.log(obj.name); // 'Alice'

¿Cómo se usa el operador de propagación (spread operator) con arrays?

Explicación: Permite que un iterable (como un array) se expanda en lugares donde se esperan cero o más argumentos o elementos. Útil para copiar, fusionar y añadir elementos.

const arr1 = [1, 2];
const arr2 = [3, 4];
const combined = [...arr1, ...arr2]; // [1, 2, 3, 4]
const copy = [...arr1]; // [1, 2]

¿Cómo se usa el operador de propagación (spread operator) con objetos?

Explicación: Permite copiar y fusionar propiedades de objetos.

const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };
const merged = { ...obj1, ...obj2 }; // { a: 1, b: 3, c: 4 }
const copy = { ...obj1 }; // { a: 1, b: 2 }

Explica la desestructuración de arrays con un ejemplo.

Explicación: Es una sintaxis que permite desempaquetar valores de arrays en variables distintas.

const [a, b] = [10, 20];
console.log(a); // 10
console.log(b); // 20

const [x, , z] = [1, 2, 3];
console.log(z); // 3

Explica la desestructuración de objetos con un ejemplo.

Explicación: Permite desempaquetar propiedades de objetos en variables distintas.

const person = { name: 'Bob', age: 25 };
const { name, age } = person;
console.log(name); // 'Bob'
console.log(age); // 25

const { name: personName } = person;
console.log(personName); // 'Bob'

¿Cómo podrías implementar una versión básica de Function.prototype.call?

Explicación: call invoca una función con un valor this especificado y argumentos proporcionados individualmente. Puedes adjuntar la función al contexto this, llamarla y luego eliminarla.

Function.prototype.myCall = function(context, ...args) {
  context = context || window;
  const uniqueId = Symbol(); // Usar una clave única
  context[uniqueId] = this;
  const result = context[uniqueId](...args);
  delete context[uniqueId];
  return result;
}

function greet(greeting, punctuation) {
  console.log(`${greeting}, ${this.name}${punctuation}`);
}

greet.myCall({ name: 'Charlie' }, 'Hi', '!'); // Hi, Charlie!

¿Cómo podrías implementar una versión básica de Function.prototype.apply?

Explicación: apply es similar a call, pero acepta los argumentos como un array.

Function.prototype.myApply = function(context, argsArray) {
  context = context || window;
  const uniqueId = Symbol();
  context[uniqueId] = this;
  const result = context[uniqueId](...(argsArray || []));
  delete context[uniqueId];
  return result;
}

function greet(greeting, punctuation) {
  console.log(`${greeting}, ${this.name}${punctuation}`);
}

greet.myApply({ name: 'David' }, ['Hello', '.']); // Hello, David.

Explica brevemente el Bucle de Eventos de JavaScript.

Explicación: JavaScript es de un solo hilo, pero logra la concurrencia utilizando un bucle de eventos. La pila de llamadas maneja el código síncrono. Las Web APIs manejan operaciones asíncronas (como setTimeout, fetch). Cuando una operación asíncrona termina, su callback va a la cola de callbacks (o cola de microtareas para las Promesas). El bucle de eventos comprueba constantemente si la pila de llamadas está vacía; si lo está, mueve el siguiente callback de la cola a la pila para su ejecución.

console.log('Inicio');

setTimeout(() => {
  console.log('Callback de Timeout'); // Va a la Cola de Callbacks
}, 0);

Promise.resolve().then(() => {
  console.log('Promesa Resuelta'); // Va a la Cola de Microtareas
});

console.log('Fin');

// Orden de Salida: Inicio, Fin, Promesa Resuelta, Callback de Timeout
// (Las Microtareas se ejecutan antes que las Macrotareas/Callbacks)

Implementa una función de búsqueda binaria para un array ordenado.

Explicación: La búsqueda binaria encuentra eficientemente un elemento en un array ordenado dividiendo repetidamente el intervalo de búsqueda por la mitad. Si el valor de la clave de búsqueda es menor que el elemento en el medio del intervalo, se reduce el intervalo a la mitad inferior. De lo contrario, se reduce a la mitad superior. Esto se hace hasta que se encuentra el valor o el intervalo está vacío.

function binarySearch(sortedArray, key) {
  let start = 0;
  let end = sortedArray.length - 1;

  while (start <= end) {
    let middle = Math.floor((start + end) / 2);

    if (sortedArray[middle] === key) {
      return middle; // Encontrado
    } else if (sortedArray[middle] < key) {
      start = middle + 1; // Buscar en la mitad derecha
    } else {
      end = middle - 1; // Buscar en la mitad izquierda
    }
  }
  return -1; // No encontrado
}

console.log(binarySearch([1, 3, 5, 7, 9, 11], 7)); // 3
console.log(binarySearch([1, 3, 5, 7, 9, 11], 2)); // -1

Implementa el algoritmo Merge Sort.

Explicación: Merge Sort es un algoritmo de divide y vencerás. Divide el array de entrada en dos mitades, se llama a sí mismo para las dos mitades y luego fusiona las dos mitades ordenadas. La función de fusión es crucial; combina dos sub-arrays ordenados en un array ordenado.

function mergeSort(arr) {
  if (arr.length <= 1) return arr;

  const mid = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, mid));
  const right = mergeSort(arr.slice(mid));

  return merge(left, right);
}

function merge(left, right) {
  let result = [];
  let leftIndex = 0;
  let rightIndex = 0;

  while (leftIndex < left.length && rightIndex < right.length) {
    if (left[leftIndex] < right[rightIndex]) {
      result.push(left[leftIndex]);
      leftIndex++;
    } else {
      result.push(right[rightIndex]);
      rightIndex++;
    }
  }

  return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
}

console.log(mergeSort([38, 27, 43, 3, 9, 82, 10])); // [3, 9, 10, 27, 38, 43, 82]

Implementa el algoritmo Quick Sort.

Explicación: Quick Sort también es un algoritmo de divide y vencerás. Elige un elemento como pivote y particiona el array dado alrededor del pivote elegido. Los elementos más pequeños que el pivote van a la izquierda, y los elementos más grandes van a la derecha. Luego ordena recursivamente los sub-arrays.

function quickSort(arr) {
  if (arr.length <= 1) return arr;

  const pivot = arr[arr.length - 1];
  const left = [];
  const right = [];

  for (let i = 0; i < arr.length - 1; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }

  return [...quickSort(left), pivot, ...quickSort(right)];
}

console.log(quickSort([10, 8, 2, 1, 6, 3, 9, 4, 7, 5])); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Implementa el algoritmo Bubble Sort.

Explicación: Bubble Sort es un algoritmo de ordenación simple que recorre repetidamente la lista, compara elementos adyacentes y los intercambia si están en el orden incorrecto. El paso a través de la lista se repite hasta que la lista está ordenada.

function bubbleSort(arr) {
  let n = arr.length;
  let swapped;
  do {
    swapped = false;
    for (let i = 0; i < n - 1; i++) {
      if (arr[i] > arr[i + 1]) {
        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]; // Intercambiar
        swapped = true;
      }
    }
    n--; // Optimización: el último elemento ya está en su lugar
  } while (swapped);
  return arr;
}

console.log(bubbleSort([64, 34, 25, 12, 22, 11, 90])); // [11, 12, 22, 25, 34, 64, 90]

Dada una cadena, encuentra la longitud de la subcadena más larga sin caracteres que se repitan.

Explicación: Usa la técnica de 'ventana deslizante' (sliding window). Mantén una ventana (subcadena) y un conjunto de caracteres en esa ventana. Expande la ventana moviendo el puntero derecho. Si se encuentra un carácter repetido, encoge la ventana desde la izquierda hasta que se elimine el carácter repetido.

function lengthOfLongestSubstring(s) {
  let maxLength = 0;
  let start = 0;
  const charMap = {};

  for (let end = 0; end < s.length; end++) {
    const char = s[end];
    if (charMap[char] >= start) {
        start = charMap[char] + 1;
    }
    charMap[char] = end;
    maxLength = Math.max(maxLength, end - start + 1);
  }
  return maxLength;
}

console.log(lengthOfLongestSubstring('abcabcbb')); // 3 ('abc')
console.log(lengthOfLongestSubstring('bbbbb')); // 1 ('b')
console.log(lengthOfLongestSubstring('pwwkew')); // 3 ('wke')

Implementa una Lista Enlazada Simple con los métodos add y print.

Explicación: Una lista enlazada es una estructura de datos lineal donde los elementos no se almacenan en ubicaciones de memoria contiguas. Cada elemento (nodo) apunta al siguiente. Necesitas una clase Node y una clase LinkedList para gestionar la cabeza y añadir nuevos nodos.

class Node {
  constructor(data, next = null) {
    this.data = data;
    this.next = next;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
  }

  add(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
  }

  print() {
    let current = this.head;
    let list = '';
    while (current) {
      list += current.data + ' -> ';
      current = current.next;
    }
    console.log(list + 'null');
  }
}

const list = new LinkedList();
list.add(10);
list.add(20);
list.add(30);
list.print(); // 10 -> 20 -> 30 -> null

Implementa un Árbol de Búsqueda Binaria con los métodos insert y find.

Explicación: Un BST es una estructura de datos de árbol binario basada en nodos que tiene las siguientes propiedades: el subárbol izquierdo de un nodo contiene solo nodos con claves menores que la clave del nodo. El subárbol derecho de un nodo contiene solo nodos con claves mayores que la clave del nodo. Ambos subárboles también deben ser árboles de búsqueda binaria.

class Node {
  constructor(data) {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}

class BST {
  constructor() {
    this.root = null;
  }

  insert(data) {
    const newNode = new Node(data);
    if (!this.root) {
      this.root = newNode;
      return;
    }
    this._insertNode(this.root, newNode);
  }

  _insertNode(node, newNode) {
    if (newNode.data < node.data) {
      if (!node.left) node.left = newNode;
      else this._insertNode(node.left, newNode);
    } else {
      if (!node.right) node.right = newNode;
      else this._insertNode(node.right, newNode);
    }
  }

  find(data) {
    return this._findNode(this.root, data);
  }

  _findNode(node, data) {
    if (!node) return null;
    if (data < node.data) return this._findNode(node.left, data);
    else if (data > node.data) return this._findNode(node.right, data);
    else return node;
  }
}

const bst = new BST();
bst.insert(10);
bst.insert(5);
bst.insert(15);
bst.insert(7);
console.log(bst.find(7)); // Node { data: 7, left: null, right: null }
console.log(bst.find(12)); // null

Escribe una función para rotar un array a la derecha k pasos.

Explicación: Rotar un array significa mover sus elementos. Para una rotación a la derecha, el último elemento se convierte en el primero. Repetir esto k veces funciona pero es ineficiente. Una mejor manera es usar la manipulación de arrays o calcular las nuevas posiciones.

function rotateArray(nums, k) {
  k = k % nums.length; // Manejar casos donde k > longitud
  if (k === 0) return nums;

  const partToMove = nums.splice(nums.length - k);
  nums.unshift(...partToMove);
  return nums;
}

console.log(rotateArray([1, 2, 3, 4, 5, 6, 7], 3)); // [5, 6, 7, 1, 2, 3, 4]

Dados dos arrays, escribe una función para calcular su intersección (elementos comunes a ambos).

Explicación: Un buen enfoque es convertir un array en un Set para búsquedas en tiempo promedio de O(1). Luego, itera a través del segundo array y comprueba si cada elemento existe en el set. Recoge las coincidencias.

function intersection(nums1, nums2) {
  const set1 = new Set(nums1);
  const resultSet = new Set();

  for (const num of nums2) {
    if (set1.has(num)) {
      resultSet.add(num);
    }
  }

  return [...resultSet];
}

console.log(intersection([1, 2, 2, 1], [2, 2])); // [2]
console.log(intersection([4, 9, 5], [9, 4, 9, 8, 4])); // [9, 4]

Dado un array de cadenas, agrupa los anagramas juntos.

Explicación: La clave es encontrar una firma única para cada grupo de anagramas. Una forma común es ordenar cada palabra alfabéticamente. Las palabras que resultan en la misma cadena ordenada son anagramas. Usa un mapa hash donde las claves son palabras ordenadas y los valores son arrays de palabras originales.

function groupAnagrams(strs) {
  const map = {};
  for (const str of strs) {
    const sortedStr = str.split('').sort().join('');
    if (!map[sortedStr]) {
      map[sortedStr] = [];
    }
    map[sortedStr].push(str);
  }
  return Object.values(map);
}

console.log(groupAnagrams(['eat', 'tea', 'tan', 'ate', 'nat', 'bat'])); 
// Salida: [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

Dado un array nums, escribe una función para mover todos los 0 al final, manteniendo el orden relativo de los elementos no nulos.

Explicación: Usa un enfoque de 'dos punteros' o 'bola de nieve'. Un puntero rastrea la posición donde debe ir el siguiente elemento no nulo. Itera a través del array; si un elemento no es cero, colócalo en la posición del puntero e incrementa el puntero. Finalmente, rellena el resto con ceros.

function moveZeroes(nums) {
  let nonZeroIndex = 0;

  // Mover todos los elementos no nulos al principio
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      nums[nonZeroIndex] = nums[i];
      nonZeroIndex++;
    }
  }

  // Rellenar el resto con ceros
  for (let i = nonZeroIndex; i < nums.length; i++) {
    nums[i] = 0;
  }

  return nums;
}

console.log(moveZeroes([0, 1, 0, 3, 12])); // [1, 3, 12, 0, 0]

Dado un array de enteros nums, encuentra el subarray contiguo (que contenga al menos un número) que tenga la suma más grande y devuelve su suma.

Explicación: El algoritmo de Kadane es una forma eficiente de resolver esto. Itera a través del array, manteniendo un registro de la suma currentMax que termina en la posición actual y la suma globalMax encontrada hasta ahora. Si currentMax se vuelve negativo, reinícialo a 0 (o mejor dicho, al elemento actual).

function maxSubArray(nums) {
  let globalMax = -Infinity;
  let currentMax = 0;

  for (let i = 0; i < nums.length; i++) {
    currentMax = Math.max(nums[i], currentMax + nums[i]);
    if (currentMax > globalMax) {
      globalMax = currentMax;
    }
  }
  return globalMax;
}

console.log(maxSubArray([-2, 1, -3, 4, -1, 2, 1, -5, 4])); // 6 (de [4, -1, 2, 1])