Live Coding

Como verificar se um objeto JavaScript está vazio?

Explicação: Um objeto está vazio se não possuir nenhuma propriedade enumerável própria. Podemos usar Object.keys(obj) que retorna um array com os nomes das propriedades enumeráveis de um determinado objeto. Se o comprimento deste array for 0, o objeto está vazio.

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

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

Escreva uma função para inverter uma determinada string.

Explicação: A maneira mais simples é converter a string em um array de caracteres, usar o método reverse() embutido para arrays e, em seguida, juntar os caracteres de volta em uma string.

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

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

Escreva uma função que verifica se uma determinada string é um palíndromo.

Explicação: Um palíndromo é uma palavra ou frase que se lê da mesma forma de frente para trás e de trás para frente. Podemos verificar isso invertendo a string (ignorando maiúsculas/minúsculas e caracteres não alfanuméricos para uma verificação mais robusta, mas aqui fazemos uma verificação simples) e comparando-a com a original.

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

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

Escreva uma função para encontrar o maior número em um array de números.

Explicação: Você pode iterar pelo array, acompanhando o maior número encontrado até agora. Alternativamente, você pode usar a função Math.max() junto com a sintaxe spread (...) para passar elementos do array como argumentos.

function findMaxNumber(arr) {
  if (arr.length === 0) return undefined; // Ou lançar um erro
  return Math.max(...arr);
}

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

Escreva um programa que imprima números de 1 a n. Mas para múltiplos de três, imprima 'Fizz' em vez do número e para os múltiplos de cinco, imprima 'Buzz'. Para números que são múltiplos de três e cinco, imprima 'FizzBuzz'.

Explicação: Este problema clássico testa a lógica básica de loop e condicional. Você precisa iterar de 1 a n e usar o operador de módulo (%) para verificar a divisibilidade por 3 e 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);

Escreva uma função que remove elementos duplicados de um array.

Explicação: Uma maneira moderna e concisa de conseguir isso é usando um Set. Sets armazenam apenas valores únicos. Você pode converter o array para um Set e depois de volta para um array.

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

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

Escreva uma função para verificar se duas strings são anagramas uma da outra.

Explicação: Anagramas são palavras formadas pela reorganização das letras de outra. Para verificar, podemos limpar, ordenar e comparar as strings. A limpeza envolve a remoção de caracteres não alfanuméricos e a conversão para um caso consistente.

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

Escreva uma função para calcular o fatorial de um inteiro não negativo.

Explicação: O fatorial (n!) de um número é o produto de todos os inteiros positivos menores ou iguais a n. Podemos calcular isso iterativamente multiplicando os números de 1 até n.

function factorial(n) {
  if (n < 0) return undefined; // Fatorial não é 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

Escreva uma função que retorna a soma de todos os números em um array.

Explicação: Você pode usar o método reduce, que é ideal para acumular um único valor de um array. Ele recebe uma função de callback e um valor inicial (0 para soma).

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

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

Escreva uma função para achatar um array aninhado. Para simplificar, assuma apenas um nível de aninhamento.

Explicação: Para um único nível de aninhamento, você pode usar Array.prototype.concat() com o operador spread ou o método flat() (ES2019).

function flattenArray(arr) {
  // Usando flat() (mais simples se ES2019+ for aceitável)
  // return arr.flat();

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

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

Escreva uma função que conta o número de vogais (a, e, i, o, u) em uma determinada string.

Explicação: Itere pela string (ignorando maiúsculas/minúsculas) e verifique se cada caractere é uma vogal. Mantenha um 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

Escreva uma função que converte uma frase para o formato de título (a primeira letra de cada palavra em maiúscula).

Explicação: Divida a frase em palavras, depois itere por cada palavra, capitalizando a primeira letra e tornando o restante minúsculo. Finalmente, junte as palavras de volta.

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 um array de inteiros nums e um inteiro target, retorne os índices dos dois números de forma que eles somem target.

Explicação: Uma abordagem comum é usar um mapa hash (ou um objeto JavaScript) para armazenar números e seus índices à medida que você itera. Para cada número, verifique se target - current_number existe no 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 []; // Ou null, ou lançar erro se não houver solução
}

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

Crie uma função que retorna uma função de contador. Cada vez que a função retornada é chamada, ela deve incrementar e retornar uma contagem.

Explicação: Isso demonstra closures. A função interna tem acesso à variável count do escopo da função externa, mesmo depois que a função externa terminou de ser executada.

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

Escreva uma função que encontra o primeiro caractere não repetido em uma string.

Explicação: Você pode usar um mapa hash para contar as frequências dos caracteres. Primeiro, itere pela string para construir o mapa de frequência. Em seguida, itere pela string novamente e retorne o primeiro caractere com uma contagem 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; // Ou algum indicador se todos se repetem
}

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

Escreva uma função que divide um array em grupos de um tamanho especificado.

Explicação: Itere pelo array, pegando fatias do tamanho especificado e as adicionando a um novo array. Lide com o caso em que o último pedaço pode ser menor.

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]]

Escreva uma função para determinar se um determinado número é um número primo.

Explicação: Um número primo é um número natural maior que 1 que não possui divisores positivos além de 1 e ele mesmo. Itere de 2 até a raiz quadrada do número, verificando a divisibilidade. Lide com casos de borda como 1 e 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

Escreva uma função que encontra a palavra mais longa em uma frase.

Explicação: Divida a string em um array de palavras. Em seguida, itere pelo array, acompanhando a palavra mais longa encontrada até agora (ou seu comprimento).

function findLongestWord(str) {
  const words = str.split(' ');
  let longestWord = '';
  for (const word of words) {
    // Limpar palavras se necessário (ex: remover pontuação)
    if (word.length > longestWord.length) {
      longestWord = word;
    }
  }
  return longestWord;
}

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

Implemente sua própria versão da função Array.prototype.map.

Explicação: A função map recebe um callback e cria um novo array aplicando o callback a cada elemento do array original. Sua função deve iterar pelo array e construir o novo 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]

Implemente sua própria versão da função Array.prototype.filter.

Explicação: A função filter recebe um callback e cria um novo array com todos os elementos que passam no teste implementado pela função de callback fornecida.

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']

Implemente sua própria versão da função Array.prototype.reduce.

Explicação: A função reduce executa uma função de callback 'redutora' fornecida pelo usuário em cada elemento do array, passando o valor de retorno do cálculo no elemento precedente. O resultado final da execução do redutor em todos os elementos do array é um único valor. Lide com o argumento de valor inicial.

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

  if (initialValue === undefined) {
      if (arr.length === 0) throw new TypeError('Reduce of empty array with no initial value');
      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

Implemente uma função Fibonacci usando memorização para otimizar o desempenho.

Explicação: A sequência de Fibonacci envolve cálculos repetidos. A memorização armazena os resultados de chamadas de função caras e retorna o resultado em cache quando as mesmas entradas ocorrem novamente.

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 (muito mais rápido que o não memorizado)

Escreva uma função para verificar se uma string contendo chaves {}[]() está balanceada.

Explicação: Use uma pilha. Ao encontrar um colchete de abertura, coloque-o na pilha. Ao encontrar um colchete de fechamento, verifique se a pilha está vazia ou se o elemento superior é o colchete de abertura correspondente. Se corresponder, retire da pilha. Se não, ou se a pilha estiver vazia, está desbalanceado. No final, uma pilha vazia significa balanceado.

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

Implemente uma estrutura de dados de Fila com os métodos enqueue (adicionar ao final) e dequeue (remover do início).

Explicação: Uma fila segue o princípio FIFO (First-In, First-Out). Um array pode ser usado, com push para enqueue e 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

Implemente uma estrutura de dados de Pilha com os métodos push (adicionar ao topo) e pop (remover do topo).

Explicação: Uma pilha segue o princípio LIFO (Last-In, First-Out). Um array pode ser usado, com os métodos push e 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 um array contendo n números distintos tirados de 0, 1, 2, ..., n, encontre o que está faltando no array.

Explicação: A soma dos números de 0 a n pode ser calculada usando a fórmula n*(n+1)/2. A soma real dos elementos do array pode ser calculada. A diferença entre essas duas somas será o número ausente.

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

Implemente uma função debounce. Debouncing garante que uma função não seja chamada novamente até que uma certa quantidade de tempo tenha passado sem que ela seja chamada.

Explicação: Use setTimeout e clearTimeout. Cada vez que a função 'debounced' é chamada, limpe o timeout anterior e defina um novo. A chamada real da função acontece apenas quando o timeout é concluído.

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

// Exemplo de uso:
const sayHello = () => console.log('Hello!');
const debouncedHello = debounce(sayHello, 1000);
debouncedHello(); // Chamado após 1 seg (se não for chamado novamente)
debouncedHello(); // Reinicia o timer
debouncedHello(); // Reinicia o timer, será executado 1 seg após esta chamada.

Implemente uma função throttle. Throttling garante que uma função seja chamada no máximo uma vez em um intervalo de tempo especificado.

Explicação: Use uma flag para indicar se uma chamada é permitida. Quando chamada, se permitido, execute a função, defina a flag como false e use setTimeout para redefinir a flag após o intervalo.

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

// Exemplo de uso:
const logScroll = () => console.log('Scrolling...');
const throttledScroll = throttle(logScroll, 1000);
// window.addEventListener('scroll', throttledScroll); // Irá registrar no máximo uma vez por segundo.

Escreva uma função que recebe uma função com dois argumentos e retorna uma versão 'curried' dela.

Explicação: Currying transforma uma função com múltiplos argumentos em uma sequência de funções, cada uma recebendo um único argumento. f(a, b) se torna 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

Escreva uma função para realizar uma clonagem profunda de um objeto JavaScript.

Explicação: Um clone raso copia apenas as propriedades de nível superior. Um clone profundo copia recursivamente todas as propriedades, incluindo objetos e arrays aninhados. Uma maneira simples (com limitações, por exemplo, não lida bem com funções, datas, regex) é usar JSON.parse(JSON.stringify(obj)). Uma abordagem recursiva é mais robusta.

function deepClone(obj) {
  // Versão simples (com limitações)
  try {
      return JSON.parse(JSON.stringify(obj));
  } catch (e) {
      console.error("Clonagem falhou:", e);
      return null;
  }
  
  // Mais robusto recursivo (exemplo 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 (prova que é um clone profundo)
console.log(cloned.b.c); // 3

Como obter um array de chaves de um objeto?

Explicação: Use Object.keys(obj).

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

Como obter um array de valores de um objeto?

Explicação: Use Object.values(obj).

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

Como verificar se um array contém um valor específico?

Explicação: Use Array.prototype.includes(value).

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

Como mesclar dois arrays em um só?

Explicação: Use a sintaxe spread (...) ou Array.prototype.concat().

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

A que se refere this no escopo global em um navegador?

Explicação: No contexto de execução global (fora de qualquer função), this se refere ao objeto global, que é window em navegadores web.

console.log(this === window); // true (em um ambiente de navegador)

A que se refere this quando usado dentro de um método de objeto?

Explicação: Quando uma função é chamada como um método de um objeto, this se refere ao objeto no qual o método é chamado.

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

Como as arrow functions lidam com this?

Explicação: As arrow functions não possuem seu próprio contexto this. Em vez disso, elas herdam this do escopo (léxico) circundante onde são definidas.

function MyClass() {
  this.value = 42;
  setTimeout(() => {
    console.log(this.value); // Registra 42 porque 'this' é herdado
  }, 100);
}
new MyClass();

Quais são as principais diferenças entre let, const e var?

Explicação: var tem escopo de função e é içado (hoisted). let e const têm escopo de bloco e são içados, mas estão em uma 'zona morta temporal' até a declaração. const deve ser inicializado e não pode ser reatribuído.

function scopeTest() {
  var a = 1;
  let b = 2;
  const c = 3;
  if (true) {
    var a = 10; // Redefine e afeta o 'a' externo
    let b = 20; // Novo 'b' dentro do bloco
    // const c = 30; // Seria um novo 'c'
    console.log(a, b, c); // 10, 20, 3
  }
  console.log(a, b, c); // 10, 2, 3
}
scopeTest();

Explique o que é uma Promise em JavaScript.

Explicação: Uma Promise é um objeto que representa a eventual conclusão (ou falha) de uma operação assíncrona e seu valor resultante. Ela pode estar em um de três estados: pendente, cumprida ou rejeitada.

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('Sucesso!');
    // reject('Erro!');
  }, 1000);
});

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

Como async e await simplificam o trabalho com Promises?

Explicação: async/await fornece açúcar sintático sobre Promises, fazendo com que o código assíncrono pareça e se comporte um pouco mais como código síncrono. Uma função async sempre retorna uma Promise, e await pausa a execução até que uma Promise se resolva.

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

async function run() {
  console.log('Iniciando...');
  await delay(1000);
  console.log('Esperou 1 segundo.');
  await delay(500);
  console.log('Esperou mais 0.5 segundos.');
  return 'Concluído!';
}

run().then(console.log);

Como converter uma string para um número?

Explicação: Use parseInt(), parseFloat() ou o operador de adição unário (+).

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

Como converter um número para uma string?

Explicação: Use String(), number.toString() ou concatenação de strings.

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

O que JSON.stringify faz?

Explicação: Ele converte um objeto ou valor JavaScript para uma string JSON.

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

O que JSON.parse faz?

Explicação: Ele analisa uma string JSON, construindo o valor ou objeto JavaScript descrito pela string.

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

Como o operador spread é usado com arrays?

Explicação: Ele permite que um iterável (como um array) seja expandido em locais onde zero ou mais argumentos ou elementos são esperados. Útil para copiar, mesclar e adicionar elementos.

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

Como o operador spread é usado com objetos?

Explicação: Ele permite copiar e mesclar propriedades 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 }

Explique a desestruturação de array com um exemplo.

Explicação: É uma sintaxe que torna possível desempacotar valores de arrays em variáveis distintas.

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

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

Explique a desestruturação de objetos com um exemplo.

Explicação: Torna possível desempacotar propriedades de objetos em variáveis 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'

Como você poderia implementar uma versão básica de Function.prototype.call?

Explicação: call invoca uma função com um valor this especificado e argumentos fornecidos individualmente. Você pode anexar a função ao contexto this, chamá-la e depois removê-la.

Function.prototype.myCall = function(context, ...args) {
  context = context || window;
  const uniqueId = Symbol(); // Usar uma chave ú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!

Como você poderia implementar uma versão básica de Function.prototype.apply?

Explicação: apply é semelhante a call, mas aceita argumentos como um 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.

Explique brevemente o Event Loop do JavaScript.

Explicação: JavaScript é single-threaded, mas alcança concorrência usando um event loop. A 'call stack' lida com código síncrono. As Web APIs lidam com operações assíncronas (como setTimeout, fetch). Quando uma operação assíncrona termina, seu callback vai para a 'callback queue' (ou 'microtask queue' para Promises). O event loop verifica constantemente se a 'call stack' está vazia; se estiver, ele move o próximo callback da fila para a pilha para execução.

console.log('Início');

setTimeout(() => {
  console.log('Callback de Timeout'); // Vai para a Callback Queue
}, 0);

Promise.resolve().then(() => {
  console.log('Promise Resolvida'); // Vai para a Microtask Queue
});

console.log('Fim');

// Ordem de Saída: Início, Fim, Promise Resolvida, Callback de Timeout
// (Microtasks são executadas antes de Macrotasks/Callbacks)

Implemente uma função de busca binária para um array ordenado.

Explicação: A busca binária encontra eficientemente um item em um array ordenado, dividindo repetidamente o intervalo de busca pela metade. Se o valor da chave de busca for menor que o item no meio do intervalo, reduza o intervalo para a metade inferior. Caso contrário, reduza para a metade superior. Você faz isso até que o valor seja encontrado ou o intervalo esteja vazio.

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; // Busca na metade direita
    } else {
      end = middle - 1; // Busca na metade esquerda
    }
  }
  return -1; // Não encontrado
}

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

Implemente o algoritmo Merge Sort.

Explicação: Merge Sort é um algoritmo de divisão e conquista. Ele divide o array de entrada em duas metades, chama a si mesmo para as duas metades e, em seguida, mescla as duas metades ordenadas. A função de mesclagem é crucial; ela combina dois sub-arrays ordenados em um único 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]

Implemente o algoritmo Quick Sort.

Explicação: Quick Sort também é um algoritmo de divisão e conquista. Ele escolhe um elemento como pivô e particiona o array dado em torno do pivô escolhido. Elementos menores que o pivô vão para a esquerda, e elementos maiores vão para a direita. Ele então ordena recursivamente os 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]

Implemente o algoritmo Bubble Sort.

Explicação: Bubble Sort é um algoritmo de ordenação simples que percorre repetidamente a lista, compara elementos adjacentes e os troca se estiverem na ordem errada. A passagem pela lista é repetida até que a lista esteja 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]]; // Troca
        swapped = true;
      }
    }
    n--; // Otimização: o último elemento já está no lugar
  } while (swapped);
  return arr;
}

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

Dada uma string, encontre o comprimento da substring mais longa sem caracteres repetidos.

Explicação: Use a técnica de 'janela deslizante'. Mantenha uma janela (substring) e um conjunto de caracteres nessa janela. Expanda a janela movendo o ponteiro direito. Se um caractere repetido for encontrado, diminua a janela da esquerda até que o caractere repetido seja removido.

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')

Implemente uma Lista Encadeada Simples (Singly Linked List) com os métodos add e print.

Explicação: Uma lista encadeada é uma estrutura de dados linear onde os elementos não são armazenados em locais de memória contíguos. Cada elemento (nó) aponta para o próximo. Você precisa de uma classe Node e uma classe LinkedList para gerenciar a cabeça e adicionar novos nós.

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

Implemente uma Árvore de Busca Binária (BST) com os métodos insert e find.

Explicação: Uma BST é uma estrutura de dados de árvore binária baseada em nós que possui as seguintes propriedades: A subárvore esquerda de um nó contém apenas nós com chaves menores que a chave do nó. A subárvore direita de um nó contém apenas nós com chaves maiores que a chave do nó. Ambas as subárvores também devem ser árvores de busca binária.

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

Escreva uma função para rotacionar um array para a direita em k passos.

Explicação: Rotacionar um array significa mover seus elementos. Para uma rotação para a direita, o último elemento se torna o primeiro. Repetir isso k vezes funciona, mas é ineficiente. Uma maneira melhor é usar manipulação de array ou calcular as novas posições.

function rotateArray(nums, k) {
  k = k % nums.length; // Lida com casos em que k > length
  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 dois arrays, escreva uma função para calcular sua interseção (elementos comuns a ambos).

Explicação: Uma boa abordagem é converter um array em um Set para buscas em tempo médio de O(1). Em seguida, itere pelo segundo array e verifique se cada elemento existe no conjunto. Colete as correspondências.

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 um array de strings, agrupe os anagramas juntos.

Explicação: A chave é encontrar uma assinatura única para cada grupo de anagramas. Uma maneira comum é ordenar cada palavra alfabeticamente. Palavras que resultam na mesma string ordenada são anagramas. Use um mapa hash onde as chaves são palavras ordenadas e os valores são arrays de palavras originais.

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'])); 
// Saída: [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

Dado um array nums, escreva uma função para mover todos os 0s para o final dele, mantendo a ordem relativa dos elementos não-zero.

Explicação: Use uma abordagem de 'dois ponteiros' ou 'bola de neve'. Um ponteiro acompanha a posição onde o próximo elemento não-zero deve ir. Itere pelo array; se um elemento não for zero, coloque-o na posição do ponteiro e incremente o ponteiro. Finalmente, preencha o restante com zeros.

function moveZeroes(nums) {
  let nonZeroIndex = 0;

  // Mover todos os elementos não-zero para a frente
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      nums[nonZeroIndex] = nums[i];
      nonZeroIndex++;
    }
  }

  // Preencher o restante com zeros
  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 um array de inteiros nums, encontre o sub-array contíguo (contendo pelo menos um número) que tem a maior soma e retorne sua soma.

Explicação: O algoritmo de Kadane é uma maneira eficiente de resolver isso. Itere pelo array, acompanhando a soma currentMax terminando na posição atual e a soma globalMax encontrada até agora. Se currentMax se tornar negativo, redefina-o para 0 (ou melhor, para o elemento atual).

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])