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'

เขียนฟังก์ชันที่ตรวจสอบว่าสตริงที่กำหนดเป็น Palindrome หรือไม่

คำอธิบาย: Palindrome คือคำหรือวลีที่อ่านเหมือนกันทั้งไปข้างหน้าและข้างหลัง เราสามารถตรวจสอบได้โดยการกลับสตริง (โดยไม่สนใจตัวพิมพ์และอักขระที่ไม่ใช่ตัวอักษรและตัวเลขเพื่อการตรวจสอบที่แข็งแกร่งขึ้น แต่ในที่นี้เราจะตรวจสอบแบบง่ายๆ) แล้วนำไปเปรียบเทียบกับต้นฉบับ

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 แต่สำหรับพหุคูณของสาม ให้พิมพ์ '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]

เขียนฟังก์ชันเพื่อตรวจสอบว่าสตริงสองสตริงเป็น Anagram ของกันและกันหรือไม่

คำอธิบาย: Anagram คือคำที่เกิดจากการจัดเรียงตัวอักษรของคำอื่นใหม่ หากต้องการตรวจสอบ เราสามารถล้าง จัดเรียง และเปรียบเทียบสตริงได้ การล้างเกี่ยวข้องกับการลบอักขระที่ไม่ใช่ตัวอักษรและตัวเลข และแปลงเป็นตัวพิมพ์เดียวกัน

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() ร่วมกับตัวดำเนินการกระจาย หรือเมธอด 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

เขียนฟังก์ชันที่แปลงประโยคเป็น title case (อักษรตัวแรกของแต่ละคำเป็นตัวพิมพ์ใหญ่)

คำอธิบาย: แยกประโยคเป็นคำต่างๆ จากนั้นวนซ้ำแต่ละคำ ทำให้ตัวอักษรตัวแรกเป็นตัวพิมพ์ใหญ่และส่วนที่เหลือเป็นตัวพิมพ์เล็ก สุดท้าย รวมคำกลับเข้าด้วยกัน

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

คำอธิบาย: วิธีทั่วไปคือการใช้ hash map (หรืออ็อบเจกต์ JavaScript) เพื่อจัดเก็บตัวเลขและดัชนีขณะที่คุณวนซ้ำ สำหรับแต่ละตัวเลข ให้ตรวจสอบว่า target - current_number มีอยู่ใน map หรือไม่

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]

สร้างฟังก์ชันที่คืนค่าฟังก์ชัน counter แต่ละครั้งที่เรียกใช้ฟังก์ชันที่คืนค่ามา ควรเพิ่มค่าและคืนค่าจำนวนนับ

คำอธิบาย: นี่เป็นการสาธิต closures ฟังก์ชันภายในสามารถเข้าถึงตัวแปร 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

เขียนฟังก์ชันที่ค้นหาตัวอักษรที่ไม่ซ้ำกันตัวแรกในสตริง

คำอธิบาย: คุณสามารถใช้ hash map เพื่อนับความถี่ของอักขระ ก่อนอื่น ให้วนซ้ำผ่านสตริงเพื่อสร้าง map ความถี่ จากนั้น วนซ้ำผ่านสตริงอีกครั้งและคืนค่าอักขระตัวแรกที่มีจำนวนนับเป็น 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 จะเรียกใช้ฟังก์ชันเรียกกลับ 'reducer' ที่ผู้ใช้กำหนดกับแต่ละองค์ประกอบของอาร์เรย์ โดยส่งผ่านค่าที่คืนจากการคำนวณในองค์ประกอบก่อนหน้า ผลลัพธ์สุดท้ายของการเรียกใช้ reducer กับองค์ประกอบทั้งหมดของอาร์เรย์คือค่าเดียว จัดการอาร์กิวเมนต์ค่าเริ่มต้น

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

ใช้งานฟังก์ชัน Fibonacci โดยใช้ memoization เพื่อเพิ่มประสิทธิภาพ

คำอธิบาย: ลำดับ Fibonacci เกี่ยวข้องกับการคำนวณซ้ำๆ Memoization จะจัดเก็บผลลัพธ์ของการเรียกใช้ฟังก์ชันที่ซับซ้อนและคืนค่าผลลัพธ์ที่แคชไว้เมื่ออินพุตเดียวกันเกิดขึ้นอีกครั้ง

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 (เร็วกว่าแบบไม่ใช้ memoized มาก)

เขียนฟังก์ชันเพื่อตรวจสอบว่าสตริงที่มีวงเล็บ {}[]() สมดุลหรือไม่

คำอธิบาย: ใช้ stack เมื่อพบวงเล็บเปิด ให้ผลักเข้าไปใน stack เมื่อพบวงเล็บปิด ให้ตรวจสอบว่า stack ว่างเปล่าหรือไม่ หรือถ้าองค์ประกอบบนสุดเป็นวงเล็บเปิดที่ตรงกัน หากตรงกัน ให้ pop stack หากไม่ หรือถ้า stack ว่างเปล่า แสดงว่าไม่สมดุล ในท้ายที่สุด stack ที่ว่างเปล่าหมายถึงสมดุล

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 (ลบออกจากด้านหน้า)

คำอธิบาย: Queue เป็นไปตามหลักการ First-In, First-Out (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 (ลบออกจากด้านบน)

คำอธิบาย: Stack เป็นไปตามหลักการ 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

กำหนดอาร์เรย์ที่มี 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 แต่ละครั้งที่เรียกใช้ฟังก์ชันที่ debounced ให้ล้าง timeout ก่อนหน้าและตั้งค่าใหม่ การเรียกใช้ฟังก์ชันจริงจะเกิดขึ้นเมื่อ timeout เสร็จสมบูรณ์เท่านั้น

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); // จะบันทึกมากที่สุดหนึ่งครั้งต่อวินาที

เขียนฟังก์ชันที่รับฟังก์ชันที่มีสองอาร์กิวเมนต์และคืนค่าเวอร์ชัน curried ของมัน

คำอธิบาย: Currying แปลงฟังก์ชันที่มีหลายอาร์กิวเมนต์เป็นลำดับของฟังก์ชัน โดยแต่ละฟังก์ชันจะรับอาร์กิวเมนต์เดียว 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

เขียนฟังก์ชันเพื่อดำเนินการ deep clone ของอ็อบเจกต์ JavaScript

คำอธิบาย: การโคลนแบบตื้น (shallow clone) จะคัดลอกเฉพาะคุณสมบัติระดับบนสุด การโคลนแบบลึก (deep clone) จะคัดลอกคุณสมบัติทั้งหมดแบบเรียกซ้ำ รวมถึงอ็อบเจกต์ที่ซ้อนกันและอาร์เรย์ วิธีง่ายๆ (มีข้อจำกัด เช่น ไม่จัดการฟังก์ชัน วันที่ regex ได้ดี) คือการใช้ 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 (พิสูจน์ว่าเป็น deep clone)
console.log(cloned.b.c); // 3

จะรับอาร์เรย์ของ keys จากอ็อบเจกต์ได้อย่างไร?

คำอธิบาย: ใช้ Object.keys(obj)

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

จะรับอาร์เรย์ของ values จากอ็อบเจกต์ได้อย่างไร?

คำอธิบาย: ใช้ 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

จะรวมสองอาร์เรย์เป็นหนึ่งเดียวได้อย่างไร?

คำอธิบาย: ใช้ไวยากรณ์การกระจาย (...) หรือ Array.prototype.concat()

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

this หมายถึงอะไรใน global scope ในเบราว์เซอร์?

คำอธิบาย: ในบริบทการดำเนินการทั่วโลก (ภายนอกฟังก์ชันใดๆ) this หมายถึงอ็อบเจกต์ทั่วโลก ซึ่งคือ window ในเว็บเบราว์เซอร์

console.log(this === window); // true (ในสภาพแวดล้อมเบราว์เซอร์)

this หมายถึงอะไรเมื่อใช้ภายใน object method?

คำอธิบาย: เมื่อฟังก์ชันถูกเรียกใช้เป็นเมธอดของอ็อบเจกต์ this จะหมายถึงอ็อบเจกต์ที่เมธอดนั้นถูกเรียกใช้

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

Arrow functions จัดการ this อย่างไร?

คำอธิบาย: Arrow functions ไม่มีบริบท this ของตนเอง แต่จะสืบทอด this จากขอบเขต (lexical) ที่อยู่รอบๆ ที่ถูกกำหนด

function MyClass() {
  this.value = 42;
  setTimeout(() => {
    console.log(this.value); // แสดง 42 เพราะ 'this' ถูกสืบทอดมา
  }, 100);
}
new MyClass();

ความแตกต่างหลักระหว่าง let, const, และ var คืออะไร?

คำอธิบาย: var เป็น function-scoped และ hoisted let และ const เป็น block-scoped และ hoisted แต่จะอยู่ใน 'temporal dead zone' จนกว่าจะมีการประกาศ 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 คืออ็อบเจกต์ที่แสดงถึงการสำเร็จ (หรือล้มเหลว) ของการดำเนินการแบบอะซิงโครนัสและค่าที่เป็นผลลัพธ์ สามารถอยู่ในสถานะใดสถานะหนึ่งจากสามสถานะ: pending, fulfilled, หรือ rejected

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 เป็น syntactic sugar สำหรับ Promises ทำให้โค้ดแบบอะซิงโครนัสดูและทำงานคล้ายกับโค้ดแบบซิงโครนัสมากขึ้น ฟังก์ชัน 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(), หรือตัวดำเนินการบวกแบบ unary (+)

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 operator กับ arrays อย่างไร?

คำอธิบาย: ช่วยให้ iterable (เช่น อาร์เรย์) สามารถขยายได้ในที่ที่คาดว่าจะมีศูนย์หรือมากกว่าหนึ่งอาร์กิวเมนต์หรือองค์ประกอบ มีประโยชน์สำหรับการคัดลอก การรวม และการเพิ่มองค์ประกอบ

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

มีการใช้ spread operator กับ objects อย่างไร?

คำอธิบาย: ช่วยให้สามารถคัดลอกและรวมคุณสมบัติของอ็อบเจกต์ได้

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 }

อธิบาย array destructuring พร้อมตัวอย่าง

คำอธิบาย: เป็นไวยากรณ์ที่ทำให้สามารถแกะค่าออกจากอาร์เรย์ให้เป็นตัวแปรที่แตกต่างกันได้

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

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

อธิบาย object destructuring พร้อมตัวอย่าง

คำอธิบาย: ทำให้สามารถแกะคุณสมบัติออกจากอ็อบเจกต์ให้เป็นตัวแปรที่แตกต่างกันได้

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 เป็นแบบเธรดเดียว แต่ทำงานพร้อมกันได้โดยใช้ Event Loop Call Stack จัดการโค้ดแบบ synchronous ส่วน Web API จัดการการทำงานแบบ asynchronous (เช่น setTimeout, fetch) เมื่อการทำงานแบบ asynchronous เสร็จสิ้น, callback ของมันจะไปที่ Callback Queue (หรือ Microtask Queue สำหรับ Promises) Event Loop จะตรวจสอบตลอดเวลาว่า Call Stack ว่างหรือไม่ ถ้าว่าง, มันจะย้าย callback ถัดไปจาก queue ไปยัง stack เพื่อประมวลผล

console.log('Start');

setTimeout(() => {
  console.log('Timeout Callback'); // Goes to Callback Queue
}, 0);

Promise.resolve().then(() => {
  console.log('Promise Resolved'); // Goes to Microtask Queue
});

console.log('End');

// Output Order: Start, End, Promise Resolved, Timeout Callback
// (Microtasks run before Macrotasks/Callbacks)

ใช้งานฟังก์ชัน binary search สำหรับอาร์เรย์ที่จัดเรียงแล้ว

คำอธิบาย: Binary search ค้นหารายการในอาร์เรย์ที่จัดเรียงแล้วได้อย่างมีประสิทธิภาพ โดยการแบ่งช่วงการค้นหาออกเป็นครึ่งซ้ำๆ หากค่าของคีย์การค้นหาน้อยกว่ารายการตรงกลางของช่วง, ให้จำกัดช่วงไปที่ครึ่งล่าง หากไม่เป็นเช่นนั้น, ให้จำกัดช่วงไปที่ครึ่งบน คุณจะทำเช่นนี้จนกว่าจะพบค่าหรือช่วงว่างเปล่า

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; // Found
    } else if (sortedArray[middle] < key) {
      start = middle + 1; // Search right half
    } else {
      end = middle - 1; // Search left half
    }
  }
  return -1; // Not found
}

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

ใช้งานอัลกอริทึม Merge Sort

คำอธิบาย: Merge Sort เป็นอัลกอริทึมแบบแบ่งแล้วเอาชนะ มันแบ่งอาร์เรย์ที่ป้อนเข้าออกเป็นสองส่วนครึ่ง, เรียกใช้ตัวเองสำหรับสองส่วนครึ่ง, และจากนั้นรวมสองส่วนครึ่งที่จัดเรียงแล้วเข้าด้วยกัน ฟังก์ชัน merge เป็นสิ่งสำคัญ มันรวมอาร์เรย์ย่อยสองอาร์เรย์ที่จัดเรียงแล้วเข้าเป็นอาร์เรย์เดียวที่จัดเรียงแล้ว

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]

ใช้งานอัลกอริทึม Quick Sort

คำอธิบาย: Quick Sort เป็นอัลกอริทึมแบบแบ่งแล้วเอาชนะเช่นกัน มันเลือกองค์ประกอบหนึ่งเป็น pivot และแบ่งอาร์เรย์ที่กำหนดออกเป็นส่วนๆ รอบ pivot ที่เลือก องค์ประกอบที่เล็กกว่า pivot ไปทางซ้าย และองค์ประกอบที่ใหญ่กว่าไปทางขวา จากนั้นจะจัดเรียงอาร์เรย์ย่อยซ้ำๆ

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]

ใช้งานอัลกอริทึม Bubble Sort

คำอธิบาย: Bubble Sort เป็นอัลกอริทึมการจัดเรียงที่เรียบง่าย ซึ่งจะวนซ้ำในรายการ, เปรียบเทียบองค์ประกอบที่อยู่ติดกัน, และสลับพวกมันหากอยู่ในลำดับที่ไม่ถูกต้อง การวนผ่านรายการจะทำซ้ำจนกว่ารายการจะถูกจัดเรียง

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]]; // Swap
        swapped = true;
      }
    }
    n--; // Optimization: last element is already in place
  } while (swapped);
  return arr;
}

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

กำหนดสตริง, ค้นหาความยาวของสตริงย่อยที่ยาวที่สุดที่ไม่มีอักขระซ้ำ

คำอธิบาย: ใช้เทคนิค 'sliding window' รักษา window (substring) และชุดของอักขระใน window นั้น ขยาย window โดยการย้ายตัวชี้ขวา หากพบอักขระซ้ำ, ให้หด window จากซ้ายจนกว่าอักขระซ้ำจะถูกลบออก

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

ใช้งาน Singly Linked List พร้อมเมธอด add และ print

คำอธิบาย: Linked list เป็นโครงสร้างข้อมูลเชิงเส้นที่องค์ประกอบไม่ได้จัดเก็บในตำแหน่งหน่วยความจำที่อยู่ติดกัน แต่ละองค์ประกอบ (node) จะชี้ไปยังถัดไป คุณต้องมีคลาส Node และคลาส LinkedList เพื่อจัดการ head และการเพิ่ม node ใหม่

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

ใช้งาน Binary Search Tree พร้อมเมธอด insert และ find

คำอธิบาย: BST เป็นโครงสร้างข้อมูลแบบต้นไม้ไบนารีที่อิงตามโหนด ซึ่งมีคุณสมบัติดังต่อไปนี้: subtree ซ้ายของโหนดจะมีเฉพาะโหนดที่มีคีย์น้อยกว่าคีย์ของโหนด subtree ขวาของโหนดจะมีเฉพาะโหนดที่มีคีย์มากกว่าคีย์ของโหนด ทั้งสอง subtree ต้องเป็น binary search trees ด้วย

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; // Handle cases where 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]

กำหนดอาร์เรย์สองตัว, เขียนฟังก์ชันเพื่อคำนวณส่วนที่ตัดกัน (องค์ประกอบที่เหมือนกันทั้งสอง) ของพวกมัน

คำอธิบาย: วิธีที่ดีคือการแปลงอาร์เรย์หนึ่งเป็น Set สำหรับการค้นหาด้วยเวลาเฉลี่ย O(1) จากนั้น, วนซ้ำผ่านอาร์เรย์ที่สองและตรวจสอบว่าแต่ละองค์ประกอบมีอยู่ใน 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]

กำหนดอาร์เรย์ของสตริง, จัดกลุ่ม anagrams เข้าด้วยกัน

คำอธิบาย: สิ่งสำคัญคือการค้นหาลายเซ็นที่ไม่ซ้ำกันสำหรับแต่ละกลุ่มของ anagrams วิธีทั่วไปคือการจัดเรียงแต่ละคำตามตัวอักษร คำที่ได้สตริงที่จัดเรียงแล้วเหมือนกันคือ anagrams ใช้ hash map ที่มีคีย์เป็นคำที่จัดเรียงแล้วและค่าเป็นอาร์เรย์ของคำเดิม

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

กำหนดอาร์เรย์ nums, เขียนฟังก์ชันเพื่อย้าย 0 ทั้งหมดไปที่ท้ายสุดของมัน โดยยังคงรักษาลำดับสัมพัทธ์ขององค์ประกอบที่ไม่ใช่ศูนย์

คำอธิบาย: ใช้แนวทาง 'two-pointer' หรือ 'snowball' ตัวชี้หนึ่งจะติดตามตำแหน่งที่องค์ประกอบที่ไม่ใช่ศูนย์ถัดไปควรไป วนซ้ำผ่านอาร์เรย์ หากองค์ประกอบไม่ใช่ศูนย์, ให้วางไว้ที่ตำแหน่งของตัวชี้และเพิ่มตัวชี้ สุดท้าย, เติมส่วนที่เหลือด้วยศูนย์

function moveZeroes(nums) {
  let nonZeroIndex = 0;

  // Move all non-zero elements to the front
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      nums[nonZeroIndex] = nums[i];
      nonZeroIndex++;
    }
  }

  // Fill the rest with 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]

กำหนดอาร์เรย์จำนวนเต็ม nums, ค้นหา subarray ที่ต่อเนื่องกัน (ที่มีอย่างน้อยหนึ่งหมายเลข) ที่มีผลรวมมากที่สุดและส่งคืนผลรวมนั้น

คำอธิบาย: อัลกอริทึมของ Kadane เป็นวิธีที่มีประสิทธิภาพในการแก้ปัญหานี้ วนซ้ำผ่านอาร์เรย์, ติดตามผลรวม 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 (from [4, -1, 2, 1])