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()関数とスプレッド構文 (...) を使用して、配列要素を引数として渡すこともできます。

function findMaxNumber(arr) {
  if (arr.length === 0) return undefined; // またはエラーをスローする
  return Math.max(...arr);
}

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

1からnまでの数値を表示するプログラムを作成してください。ただし、3の倍数の場合は数値の代わりに「Fizz」と表示し、5の倍数の場合は「Buzz」と表示します。3と5の両方の倍数である数値の場合は、「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は一意の値をのみ格納します。配列をSetに変換し、その後配列に戻すことができます。

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

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

2つの文字列が互いにアナグラムであるかどうかをチェックする関数を作成してください。

説明: アナグラムとは、別の単語の文字を並べ替えて作られた単語のことです。チェックするには、文字列をクリーンアップし、ソートし、比較します。クリーンアップには、非英数字の削除と一貫した大文字小文字への変換が含まれます。

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

ネストされた配列をフラット化する関数を作成してください。簡単にするために、ネストは1レベルのみとします。

説明: 1レベルのネストの場合、スプレッド演算子またはflat()メソッド（ES2019）と一緒にArray.prototype.concat()を使用できます。

function flattenArray(arr) {
  // flat() を使用（ES2019+ がOKならよりシンプル）
  // 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になる2つの数値のインデックスを返します。

説明: 一般的なアプローチは、ハッシュマップ（または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

enqueue（最後に追加）とdequeue（先頭から削除）メソッドを持つキューデータ構造を実装してください。

説明: キューはFirst-In, First-Out（FIFO）の原則に従います。配列は、enqueueにはpush、dequeueにはshiftを使用して使用できます。

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

push（上に追加）とpop（上から削除）メソッドを持つスタックデータ構造を実装してください。

説明: スタックはLast-In, First-Out（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

0, 1, 2, ..., nから取得されたn個の異なる数値を含む配列が与えられた場合、配列から欠落している数値を見つけます。

説明: 0からnまでの数値の合計は、n*(n+1)/2の式を使用して計算できます。配列要素の実際の合計を計算できます。これら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

デバウンス関数を実装してください。デバウンスは、関数が呼び出されずに一定の時間が経過するまで、関数が再度呼び出されないようにします。

説明: setTimeoutとclearTimeoutを使用します。デバウンス関数が呼び出されるたびに、以前のタイムアウトをクリアし、新しいタイムアウトを設定します。実際の関数呼び出しは、タイムアウトが完了したときにのみ行われます。

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秒後に実際に実行される。

スロットル関数を実装してください。スロットルは、関数が指定された時間間隔内で最大1回だけ呼び出されるようにします。

説明: 呼び出しが許可されているかどうかを示すフラグを使用します。呼び出されたとき、許可されていれば関数を実行し、フラグを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); // 1秒に1回までしかログが出力されない。

2つの引数を持つ関数を受け取り、そのカリー化されたバージョンを返す関数を作成してください。

説明: カリー化は、複数の引数を持つ関数を、それぞれが単一の引数を受け取る関数のシーケンスに変換します。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

2つの配列を1つに結合するにはどうすればよいですか？

説明: スプレッド構文 (...) またはArray.prototype.concat()を使用します。

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

ブラウザのグローバルスコープでは、thisは何を指しますか？

説明: グローバル実行コンテキスト（関数の外側）では、thisはグローバルオブジェクトを指し、Webブラウザでは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); // 'this'が継承されているため、42を出力
  }, 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();

JavaScriptにおけるPromiseとは何かを説明してください。

説明: Promiseは、非同期操作の最終的な完了（または失敗）とその結果の値を表すオブジェクトです。pending、fulfilled、rejectedの3つの状態のいずれかになります。

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はPromiseとの連携をどのように簡素化しますか？

説明: async/awaitはPromiseのシンタックスシュガーを提供し、非同期コードを同期コードのように見せて動作させます。async関数は常に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'

スプレッド演算子は配列でどのように使用されますか？

説明: イテラブル（配列など）が、ゼロ個以上の引数または要素が期待される場所で展開されることを可能にします。コピー、結合、要素の追加に役立ちます。

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

スプレッド演算子はオブジェクトでどのように使用されますか？

説明: オブジェクトのプロパティのコピーと結合を可能にします。

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はシングルスレッドですが、イベントループを使用して同時実行性を実現しています。コールスタックは同期コードを処理します。Web APIは非同期操作（setTimeout、fetchなど）を処理します。非同期操作が完了すると、そのコールバックはコールバックキュー（またはPromiseの場合はマイクロタスクキュー）に移動します。イベントループは、コールスタックが空であるかどうかを常にチェックし、空であれば、キューから次のコールバックをスタックに移動して実行します。

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

マージソートアルゴリズムを実装してください。

説明: マージソートは分割統治アルゴリズムです。入力配列を2つの半分に分割し、両方の半分に対して自身を呼び出し、その後、2つのソートされた半分をマージします。マージ関数が重要です。これは、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 > 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]

2つの配列が与えられた場合、それらの共通部分（両方に共通する要素）を計算する関数を作成してください。

説明: 効率的なアプローチは、一方の配列をSetに変換して平均O(1)の時間で検索できるようにすることです。次に、2番目の配列を反復処理し、各要素がSetに存在するかどうかをチェックします。一致するものを収集します。

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を最後に移動する関数を作成してください。

説明: 「2つのポインター」または「スノーボール」アプローチを使用します。1つのポインターは、次の非ゼロ要素が配置される位置を追跡します。配列を反復処理します。要素が非ゼロの場合、それをポインターの位置に配置し、ポインターをインクリメントします。最後に、残りをゼロで埋めます。

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が与えられた場合、最大の合計を持つ連続する部分配列（少なくとも1つの数値を含む）を見つけて、その合計を返します。

説明: カデインのアルゴリズムは、これを解決するための効率的な方法です。配列を反復処理し、現在の位置で終了する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]から)