Live Coding

Как проверить, является ли объект JavaScript пустым?

Объяснение: Объект пуст, если у него нет собственных перечисляемых свойств. Мы можем использовать Object.keys(obj), который возвращает массив собственных перечисляемых имен свойств данного объекта. Если длина этого массива равна 0, объект пуст.

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

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

Напишите функцию для разворачивания заданной строки.

Объяснение: Простейший способ — преобразовать строку в массив символов, использовать встроенный метод reverse() для массивов, а затем объединить символы обратно в строку.

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

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

Напишите функцию, которая проверяет, является ли заданная строка палиндромом.

Объяснение: Палиндром — это слово или фраза, которые читаются одинаково как в прямом, так и в обратном направлении. Мы можем проверить это, развернув строку (игнорируя регистр и неалфавитно-цифровые символы для более надежной проверки, но здесь мы делаем простую проверку) и сравнив ее с оригиналом.

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

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

Напишите функцию для поиска наибольшего числа в массиве чисел.

Объяснение: Вы можете перебирать массив, отслеживая наибольшее найденное число. Альтернативно, вы можете использовать функцию Math.max() вместе с оператором spread (...), чтобы передать элементы массива в качестве аргументов.

function findMaxNumber(arr) {
  if (arr.length === 0) return undefined; // Или выбросить ошибку
  return Math.max(...arr);
}

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

Напишите программу, которая выводит числа от 1 до n. Но для чисел, кратных трем, выводит 'Fizz' вместо числа, а для чисел, кратных пяти, выводит 'Buzz'. Для чисел, которые кратны как трем, так и пяти, выводит 'FizzBuzz'.

Объяснение: Эта классическая задача проверяет базовую логику циклов и условий. Вам нужно перебирать числа от 1 до n и использовать оператор по модулю (%) для проверки делимости на 3 и 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);

Напишите функцию, которая удаляет повторяющиеся элементы из массива.

Объяснение: Современный и лаконичный способ достижения этого — использование Set. Множества хранят только уникальные значения. Вы можете преобразовать массив в Set, а затем обратно в массив.

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

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

Напишите функцию для проверки, являются ли две строки анаграммами друг друга.

Объяснение: Анаграммы — это слова, образованные перестановкой букв другого слова. Для проверки мы можем очистить, отсортировать и сравнить строки. Очистка включает удаление неалфавитно-цифровых символов и преобразование в единый регистр.

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

Напишите функцию для вычисления факториала неотрицательного целого числа.

Объяснение: Факториал (n!) числа — это произведение всех положительных целых чисел, меньших или равных n. Мы можем вычислить это итеративно, умножая числа от 1 до n.

function factorial(n) {
  if (n < 0) return undefined; // Факториал не определен для отрицательных чисел
  if (n === 0) return 1;
  let result = 1;
  for (let i = 1; i <= n; i++) {
    result *= i;
  }
  return result;
}

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

Напишите функцию, которая возвращает сумму всех чисел в массиве.

Объяснение: Вы можете использовать метод reduce, который идеально подходит для накопления одного значения из массива. Он принимает функцию обратного вызова и начальное значение (0 для суммирования).

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

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

Напишите функцию для разворачивания вложенного массива. Для простоты предположим только один уровень вложенности.

Объяснение: Для одного уровня вложенности вы можете использовать Array.prototype.concat() с оператором spread или метод flat() (ES2019).

function flattenArray(arr) {
  // Использование flat() (проще, если ES2019+ подходит)
  // return arr.flat();

  // Использование reduce и concat
  return arr.reduce((acc, val) => acc.concat(val), []);
}

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

Напишите функцию, которая подсчитывает количество гласных (a, e, i, o, u) в заданной строке.

Объяснение: Переберите строку (без учета регистра) и проверьте, является ли каждый символ гласной. Поддерживайте счетчик.

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

Напишите функцию, которая преобразует предложение в регистр заголовка (первая буква каждого слова заглавная).

Объяснение: Разделите предложение на слова, затем переберите каждое слово, сделав первую букву заглавной, а остальные — строчными. Наконец, соедините слова обратно.

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'

Учитывая массив целых чисел nums и целое число target, верните индексы двух чисел, сумма которых равна target.

Объяснение: Распространенный подход — использовать хеш-карту (или объект JavaScript) для хранения чисел и их индексов по мере итерации. Для каждого числа проверяйте, существует ли target - current_number в карте.

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 []; // Или null, или выбросить ошибку, если нет решения
}

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

Создайте функцию, которая возвращает функцию счетчика. Каждый раз, когда вызывается возвращаемая функция, она должна увеличивать и возвращать счетчик.

Объяснение: Это демонстрирует замыкания. Внутренняя функция имеет доступ к переменной count из области видимости внешней функции, даже после того, как внешняя функция завершила выполнение.

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

Напишите функцию, которая находит первый неповторяющийся символ в строке.

Объяснение: Вы можете использовать хеш-карту для подсчета частоты символов. Сначала переберите строку, чтобы построить карту частот. Затем снова переберите строку и верните первый символ с числом 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; // Или какой-либо индикатор, если все повторяются
}

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

Напишите функцию, которая разбивает массив на группы заданного размера.

Объяснение: Перебирайте массив, беря срезы заданного размера и помещая их в новый массив. Обработайте случай, когда последний чанк может быть меньше.

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

Напишите функцию, которая определяет, является ли заданное число простым.

Объяснение: Простое число — это натуральное число, большее 1, которое не имеет положительных делителей, кроме 1 и самого себя. Перебирайте числа от 2 до квадратного корня из числа, проверяя на делимость. Обработайте пограничные случаи, такие как 1 и 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

Напишите функцию, которая находит самое длинное слово в предложении.

Объяснение: Разделите строку на массив слов. Затем переберите массив, отслеживая самое длинное найденное слово (или его длину).

function findLongestWord(str) {
  const words = str.split(' ');
  let longestWord = '';
  for (const word of words) {
    // Очистить слова, если необходимо (например, удалить пунктуацию)
    if (word.length > longestWord.length) {
      longestWord = word;
    }
  }
  return longestWord;
}

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

Реализуйте свою собственную версию функции Array.prototype.map.

Объяснение: Функция map принимает обратный вызов и создает новый массив, применяя обратный вызов к каждому элементу исходного массива. Ваша функция должна перебирать массив и строить новый массив.

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]

Реализуйте свою собственную версию функции Array.prototype.filter.

Объяснение: Функция filter принимает обратный вызов и создает новый массив со всеми элементами, которые проходят тест, реализованный предоставленной функцией обратного вызова.

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

Реализуйте свою собственную версию функции Array.prototype.reduce.

Объяснение: Функция reduce выполняет предоставленную пользователем функцию обратного вызова-«редуктора» для каждого элемента массива, передавая возвращаемое значение из вычисления предыдущего элемента. Конечным результатом выполнения редуктора по всем элементам массива является одно значение. Обработайте аргумент начального значения.

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

Реализуйте функцию Фибоначчи с использованием мемоизации для оптимизации производительности.

Объяснение: Последовательность Фибоначчи включает повторяющиеся вычисления. Мемоизация сохраняет результаты дорогостоящих вызовов функций и возвращает кэшированный результат, когда те же входные данные встречаются снова.

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 (гораздо быстрее, чем без мемоизации)

Напишите функцию для проверки, является ли строка, содержащая скобки {}[](), сбалансированной.

Объяснение: Используйте стек. Когда вы встречаете открывающую скобку, поместите ее в стек. Когда вы встречаете закрывающую скобку, проверьте, пуст ли стек или является ли верхний элемент соответствующей открывающей скобкой. Если совпадает, извлеките из стека. В противном случае, или если стек пуст, он несбалансирован. В конце пустой стек означает сбалансированный.

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

Реализуйте структуру данных Queue с методами enqueue (добавить в конец) и dequeue (удалить из начала).

Объяснение: Очередь следует принципу «первым пришел — первым ушел» (FIFO). Может быть использован массив с методами push для enqueue и shift для 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

Реализуйте структуру данных Stack с методами push (добавить наверх) и pop (удалить сверху).

Объяснение: Стек следует принципу «последним пришел — первым ушел» (LIFO). Может быть использован массив с методами push и 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

Дан массив, содержащий n различных чисел от 0, 1, 2, ..., n. Найдите то, которое отсутствует в массиве.

Объяснение: Сумма чисел от 0 до n может быть вычислена по формуле n*(n+1)/2. Фактическая сумма элементов массива может быть вычислена. Разница между этими двумя суммами будет пропущенным числом.

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

Реализуйте функцию debounce. Debouncing гарантирует, что функция не будет вызвана снова, пока не пройдет определенное количество времени без ее вызова.

Объяснение: Используйте setTimeout и clearTimeout. Каждый раз, когда вызывается функция debounce, очистите предыдущий тайм-аут и установите новый. Фактический вызов функции происходит только тогда, когда тайм-аут завершается.

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

// Пример использования:
const sayHello = () => console.log('Hello!');
const debouncedHello = debounce(sayHello, 1000);
debouncedHello(); // Вызов через 1 сек (если не будет вызван снова)
debouncedHello(); // Сбрасывает таймер
debouncedHello(); // Сбрасывает таймер, фактически выполнится через 1 сек после этого вызова.

Реализуйте функцию throttle. Throttling гарантирует, что функция вызывается не чаще одного раза в указанный интервал времени.

Объяснение: Используйте флаг, чтобы указать, разрешен ли вызов. При вызове, если разрешено, выполните функцию, установите флаг в false и используйте setTimeout для сброса флага после интервала.

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

// Пример использования:
const logScroll = () => console.log('Scrolling...');
const throttledScroll = throttle(logScroll, 1000);
// window.addEventListener('scroll', throttledScroll); // Будет логировать не чаще одного раза в секунду.

Напишите функцию, которая принимает функцию с двумя аргументами и возвращает ее каррированную версию.

Объяснение: Каррирование преобразует функцию с несколькими аргументами в последовательность функций, каждая из которых принимает один аргумент. f(a, b) становится 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

Напишите функцию для выполнения глубокого клонирования объекта JavaScript.

Объяснение: Поверхностное клонирование копирует только свойства верхнего уровня. Глубокое клонирование рекурсивно копирует все свойства, включая вложенные объекты и массивы. Простой способ (с ограничениями, например, плохо обрабатывает функции, даты, регулярные выражения) — использование JSON.parse(JSON.stringify(obj)). Рекурсивный подход более надежен.

function deepClone(obj) {
  // Простая версия (с ограничениями)
  try {
      return JSON.parse(JSON.stringify(obj));
  } catch (e) {
      console.error("Cloning failed:", e);
      return null;
  }
  
  // Более надежная рекурсивная (базовый пример):
  /*
  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 (доказывает, что это глубокий клон)
console.log(cloned.b.c); // 3

Как получить массив ключей из объекта?

Объяснение: Используйте Object.keys(obj).

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

Как получить массив значений из объекта?

Объяснение: Используйте Object.values(obj).

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

Как проверить, содержит ли массив определенное значение?

Объяснение: Используйте Array.prototype.includes(value).

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

Как объединить два массива в один?

Объяснение: Используйте оператор spread (...) или Array.prototype.concat().

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

На что ссылается this в глобальной области видимости в браузере?

Объяснение: В глобальном контексте выполнения (вне любой функции) this ссылается на глобальный объект, который в веб-браузерах является window.

console.log(this === window); // true (в среде браузера)

На что ссылается this при использовании внутри метода объекта?

Объяснение: Когда функция вызывается как метод объекта, this ссылается на объект, для которого вызывается метод.

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

Как стрелочные функции обрабатывают this?

Объяснение: Стрелочные функции не имеют собственного контекста this. Вместо этого они наследуют this из окружающей (лексической) области видимости, где они определены.

function MyClass() {
  this.value = 42;
  setTimeout(() => {
    console.log(this.value); // Выводит 42, потому что 'this' наследуется
  }, 100);
}
new MyClass();

Каковы основные различия между let, const и var?

Объяснение: var имеет функциональную область видимости и поднимается. let и const имеют блочную область видимости и поднимаются, но находятся в «временной мертвой зоне» до объявления. const должен быть инициализирован и не может быть переназначен.

function scopeTest() {
  var a = 1;
  let b = 2;
  const c = 3;
  if (true) {
    var a = 10; // Переопределяет и влияет на внешний 'a'
    let b = 20; // Новый 'b' внутри блока
    // const c = 30; // Был бы новым 'c'
    console.log(a, b, c); // 10, 20, 3
  }
  console.log(a, b, c); // 10, 2, 3
}
scopeTest();

Объясните, что такое Promise в JavaScript.

Объяснение: Promise — это объект, представляющий окончательное завершение (или отказ) асинхронной операции и ее результирующее значение. Он может находиться в одном из трех состояний: ожидание, выполнено или отклонено.

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

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

Как async и await упрощают работу с Promises?

Объяснение: async/await предоставляет синтаксический сахар над Promises, делая асинхронный код выглядящим и ведущим себя немного больше как синхронный код. Асинхронная функция всегда возвращает Promise, а await приостанавливает выполнение до тех пор, пока Promise не разрешится.

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

async function run() {
  console.log('Starting...');
  await delay(1000);
  console.log('Waited 1 second.');
  await delay(500);
  console.log('Waited another 0.5 seconds.');
  return 'Finished!';
}

run().then(console.log);

Как преобразовать строку в число?

Объяснение: Используйте parseInt(), parseFloat() или унарный оператор плюс (+).

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

Как преобразовать число в строку?

Объяснение: Используйте String(), number.toString() или конкатенацию строк.

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

Что делает JSON.stringify?

Объяснение: Он преобразует объект или значение JavaScript в строку JSON.

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

Что делает JSON.parse?

Объяснение: Он разбирает строку JSON, конструируя значение или объект JavaScript, описанный строкой.

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

Как используется оператор spread с массивами?

Объяснение: Он позволяет расширять итерируемый объект (например, массив) в местах, где ожидается ноль или более аргументов или элементов. Полезно для копирования, слияния и добавления элементов.

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

Как используется оператор spread с объектами?

Объяснение: Он позволяет копировать и объединять свойства объекта.

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 }

Объясните деструктуризацию массивов на примере.

Объяснение: Это синтаксис, который позволяет распаковывать значения из массивов в отдельные переменные.

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

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

Объясните деструктуризацию объектов на примере.

Объяснение: Это позволяет распаковывать свойства из объектов в отдельные переменные.

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'

Как можно реализовать базовую версию Function.prototype.call?

Объяснение: call вызывает функцию с указанным значением this и аргументами, предоставленными по отдельности. Вы можете прикрепить функцию к контексту this, вызвать ее, а затем удалить.

Function.prototype.myCall = function(context, ...args) {
  context = context || window;
  const uniqueId = Symbol(); // Использовать уникальный ключ
  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!

Как можно реализовать базовую версию Function.prototype.apply?

Объяснение: apply аналогичен call, но принимает аргументы в виде массива.

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.

Кратко объясните цикл событий JavaScript.

Объяснение: JavaScript является однопоточным, но достигает параллелизма с помощью цикла событий. Стек вызовов обрабатывает синхронный код. Веб-API обрабатывают асинхронные операции (например, setTimeout, fetch). Когда асинхронная операция завершается, ее обратный вызов переходит в очередь обратного вызова (или очередь микрозадач для Promises). Цикл событий постоянно проверяет, пуст ли стек вызовов; если это так, он перемещает следующий обратный вызов из очереди в стек для выполнения.

console.log('Start');

setTimeout(() => {
  console.log('Timeout Callback'); // Переходит в очередь обратного вызова
}, 0);

Promise.resolve().then(() => {
  console.log('Promise Resolved'); // Переходит в очередь микрозадач
});

console.log('End');

// Порядок вывода: Start, End, Promise Resolved, Timeout Callback
// (Микрозадачи выполняются до макрозадач/обратных вызовов)

Реализуйте функцию бинарного поиска для отсортированного массива.

Объяснение: Бинарный поиск эффективно находит элемент в отсортированном массиве путем многократного деления интервала поиска пополам. Если значение ключа поиска меньше элемента в середине интервала, сузьте интервал до нижней половины. В противном случае, сузьте его до верхней половины. Вы делаете это до тех пор, пока значение не будет найдено или интервал не станет пустым.

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; // Найдено
    } else if (sortedArray[middle] < key) {
      start = middle + 1; // Искать в правой половине
    } else {
      end = middle - 1; // Искать в левой половине
    }
  }
  return -1; // Не найдено
}

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

Реализуйте алгоритм сортировки слиянием.

Объяснение: Сортировка слиянием — это алгоритм «разделяй и властвуй». Он делит входной массив на две половины, вызывает себя для двух половин, а затем объединяет две отсортированные половины. Функция слияния имеет решающее значение; она объединяет два отсортированных подмассива в один отсортированный массив.

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]

Реализуйте алгоритм быстрой сортировки.

Объяснение: Быстрая сортировка также является алгоритмом «разделяй и властвуй». Он выбирает элемент в качестве опорного и разделяет заданный массив вокруг выбранного опорного элемента. Элементы, меньшие опорного, идут влево, а элементы, большие, идут вправо. Затем он рекурсивно сортирует подмассивы.

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]

Реализуйте алгоритм пузырьковой сортировки.

Объяснение: Пузырьковая сортировка — это простой алгоритм сортировки, который многократно проходит по списку, сравнивает соседние элементы и меняет их местами, если они расположены неправильно. Проход по списку повторяется до тех пор, пока список не будет отсортирован.

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]]; // Обмен
        swapped = true;
      }
    }
    n--; // Оптимизация: последний элемент уже на месте
  } while (swapped);
  return arr;
}

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

Дана строка, найдите длину самой длинной подстроки без повторяющихся символов.

Объяснение: Используйте технику «скользящего окна». Поддерживайте окно (подстроку) и набор символов в этом окне. Расширяйте окно, перемещая правый указатель. Если найден повторяющийся символ, сузьте окно слева до тех пор, пока повторяющийся символ не будет удален.

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

Реализуйте односвязный список с методами add и print.

Объяснение: Связный список — это линейная структура данных, где элементы не хранятся в смежных ячейках памяти. Каждый элемент (узел) указывает на следующий. Вам нужен класс Node и класс LinkedList для управления головой и добавления новых узлов.

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

Реализуйте двоичное дерево поиска с методами insert и find.

Объяснение: BST — это древовидная структура данных, основанная на узлах, которая обладает следующими свойствами: левое поддерево узла содержит только узлы с ключами меньшими, чем ключ узла. Правое поддерево узла содержит только узлы с ключами большими, чем ключ узла. Оба поддерева также должны быть двоичными деревьями поиска.

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

Напишите функцию для поворота массива вправо на k шагов.

Объяснение: Поворот массива означает перемещение его элементов. При повороте вправо последний элемент становится первым. Повторение этого k раз работает, но неэффективно. Лучший способ — использовать манипуляции с массивом или вычислять новые позиции.

function rotateArray(nums, k) {
  k = k % nums.length; // Обработка случаев, когда k > длины
  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]

Даны два массива, напишите функцию для вычисления их пересечения (элементы, общие для обоих).

Объяснение: Хороший подход — преобразовать один массив в Set для поиска со средней сложностью O(1). Затем переберите второй массив и проверьте, существует ли каждый элемент в наборе. Соберите совпадения.

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]

Дан массив строк, сгруппируйте анаграммы вместе.

Объяснение: Главное — найти уникальную сигнатуру для каждой группы анаграмм. Распространенный способ — отсортировать каждое слово в алфавитном порядке. Слова, которые приводят к одной и той же отсортированной строке, являются анаграммами. Используйте хеш-карту, где ключами являются отсортированные слова, а значениями — массивы исходных слов.

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'])); 
// Вывод: [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

Дан массив nums, напишите функцию для перемещения всех 0 в конец, сохраняя относительный порядок ненулевых элементов.

Объяснение: Используйте подход «два указателя» или «снежный ком». Один указатель отслеживает позицию, куда должен быть помещен следующий ненулевой элемент. Переберите массив; если элемент ненулевой, поместите его на позицию указателя и увеличьте указатель. Наконец, заполните остаток нулями.

function moveZeroes(nums) {
  let nonZeroIndex = 0;

  // Переместите все ненулевые элементы в начало
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      nums[nonZeroIndex] = nums[i];
      nonZeroIndex++;
    }
  }

  // Заполните остаток нулями
  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]

Дан целочисленный массив nums, найдите непрерывный подмассив (содержащий хотя бы одно число), который имеет наибольшую сумму, и верните его сумму.

Объяснение: Алгоритм Кадане — это эффективный способ решения этой задачи. Переберите массив, отслеживая currentMax сумму, заканчивающуюся на текущей позиции, и globalMax сумму, найденную до сих пор. Если currentMax становится отрицательным, сбросьте его до 0 (или, скорее, до текущего элемента).

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 (из [4, -1, 2, 1])