เบเบฒเบ™เปเบเป‰เป„เบ‚เบšเบฑเบ™เบซเบฒเบˆเบฒเบเบเบฒเบ™เบชเปเบฒเบžเบฒเบ” Google เปƒเบ™ JavaScript: 4 เบงเบดเบ—เบตเบ—เบตเปˆเปเบ•เบเบ•เปˆเบฒเบ‡เบเบฑเบ™

เบเบฒเบ™เปเบเป‰เป„เบ‚เบšเบฑเบ™เบซเบฒเบˆเบฒเบเบเบฒเบ™เบชเปเบฒเบžเบฒเบ” Google เปƒเบ™ JavaScript: 4 เบงเบดเบ—เบตเบ—เบตเปˆเปเบ•เบเบ•เปˆเบฒเบ‡เบเบฑเบ™

เปƒเบ™เป€เบงเบฅเบฒเบ—เบตเปˆเบ‚เป‰เบฒเบžเบฐเป€เบˆเบปเป‰เบฒเป„เบ”เป‰เบชเบถเบเบชเบฒเบเบฒเบ™เบ›เบฐเบ•เบดเบšเบฑเบ”เบ‚เบญเบ‡ algorithms, เบ‚เป‰เบฒเบžเบฐเป€เบˆเบปเป‰เบฒเป„เบ”เป‰เบžเบปเบšเป€เบซเบฑเบ™เบ™เบตเป‰ เบ™เบตเป‰เปเบกเปˆเบ™เบงเบดเบ”เบตเป‚เบญเบ‚เบญเบ‡เบเบฒเบ™เบชเปเบฒเบžเบฒเบ”เปเบšเบšเบˆเปเบฒเบฅเบญเบ‡เบ‚เบญเบ‡ Google.. เบกเบฑเบ™เบšเปเปˆเบžเบฝเบ‡เปเบ•เปˆเปƒเบซเป‰เบ„เบงเบฒเบกเบ„เบดเบ”เบ‚เบญเบ‡เบงเบดเบ—เบตเบเบฒเบ™เบชเปเบฒเบžเบฒเบ”เปเบกเปˆเบ™เบ”เปเบฒเป€เบ™เบตเบ™เบขเบนเปˆเปƒเบ™เบšเปเบฅเบดเบชเบฑเบ”เป€เบ•เบฑเบเป‚เบ™เป‚เบฅเบขเบตเบ‚เบฐเบซเบ™เบฒเบ”เปƒเบซเบเปˆ, เปเบ•เปˆเบเบฑเบ‡เบŠเปˆเบงเบเปƒเบซเป‰เบ—เปˆเบฒเบ™เป€เบ‚เบปเป‰เบฒเปƒเบˆเบงเบดเบ—เบตเบเบฒเบ™เปเบเป‰เป„เบ‚เบšเบฑเบ™เบซเบฒ algorithmic เบ—เบตเปˆเบกเบตเบ›เบฐเบชเบดเบ”เบ—เบดเบžเบฒเบšเป€เบ—เบปเปˆเบฒเบ—เบตเปˆเป€เบ›เบฑเบ™เป„เบ›เป„เบ”เป‰.

เบšเบปเบ”โ€‹เบ„เบงเบฒเบกโ€‹เบ™เบตเป‰โ€‹เปเบกเปˆเบ™โ€‹เบ›เบฐโ€‹เป€เบžเบ”โ€‹เบ‚เบญเบ‡โ€‹เบเบฒเบ™โ€‹เบฎเปˆเบงเบกโ€‹เบเบฑเบšโ€‹เบงเบดโ€‹เบ”เบตโ€‹เป‚เบญโ€‹เป„เบ”เป‰โ€‹. เปƒเบ™เบกเบฑเบ™เบ‚เป‰เบญเบเปƒเบซเป‰เบ„เปเบฒเบ„เบดเบ”เบ„เปเบฒเป€เบซเบฑเบ™เบเปˆเบฝเบงเบเบฑเบšเบเบฒเบ™เปเบเป‰เป„เบ‚เบ—เบฑเบ‡เบซเบกเบปเบ”เบ—เบตเปˆเบชเบฐเปเบ”เบ‡, เบšเบงเบเบเบฑเบšเบเบฒเบ™เปเบเป‰เป„เบ‚เบชเบฐเบšเบฑเบšเบ‚เบญเบ‡เบ‚เป‰เบญเบเป€เบญเบ‡เปƒเบ™ JavaScript. เบเบฒเบ™ nuances เบ‚เบญเบ‡เปเบ•เปˆเบฅเบฐ algorithm เปเบกเปˆเบ™เบเบฑเบ‡เบชเบปเบ™เบ—เบฐเบ™เบฒ.

เบžเบงเบเป€เบฎเบปเบฒเป€เบ•เบทเบญเบ™: เบชเปเบฒเบฅเบฑเบšเบœเบนเป‰เบญเปˆเบฒเบ™เบ—เบฑเบ‡เบซเบกเบปเบ”เบ‚เบญเบ‡ "Habr" - เบชเปˆเบงเบ™เบซเบผเบธเบ” 10 rubles เป€เบกเบทเปˆเบญเบฅเบปเบ‡เบ—เบฐเบšเบฝเบ™เปƒเบ™เบซเบผเบฑเบเบชเบนเบ” Skillbox เป‚เบ”เบเปƒเบŠเป‰เบฅเบฐเบซเบฑเบ”เบชเบปเปˆเบ‡เป€เบชเบตเบก "Habr".

Skillbox เปเบ™เบฐเบ™เปเบฒ: เบซเบผเบฑเบเบชเบนเบ”เบžเบฒเบเบ›เบฐเบ•เบดเบšเบฑเบ” "เบœเบนเป‰เบžเบฑเบ”เบ—เบฐเบ™เบฒเบกเบทเบ–เบท PRO".

เบเบฒเบ™เบชเป‰เบฒเบ‡เบšเบฑเบ™เบซเบฒ

เบžเบงเบเป€เบฎเบปเบฒเป„เบ”เป‰เบฎเบฑเบš array เบ„เปเบฒเบชเบฑเปˆเบ‡เปเบฅเบฐเบ„เปˆเบฒเบชเบฐเป€เบžเบฒเบฐ. เบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™, เบกเบฑเบ™เบ–เบทเบเบฎเป‰เบญเบ‡เบ‚เปเปƒเบซเป‰เบชเป‰เบฒเบ‡เบŸเบฑเบ‡เบŠเบฑเบ™เบ—เบตเปˆเปƒเบซเป‰เบœเบปเบ™เบ•เบญเบšเปเบ—เบ™เป€เบ›เบฑเบ™เบˆเบดเบ‡เบซเบผเบทเบœเบดเบ”เบ‚เบถเป‰เบ™เบเบฑเบšเบงเปˆเบฒเบœเบปเบ™เบฅเบงเบกเบ‚เบญเบ‡เบชเบญเบ‡เบ•เบปเบงเป€เบฅเบเปƒเบ”เป†เปƒเบ™เบญเบฒเป€เบฃเบชเบฒเบกเบฒเบ”เป€เบ—เบปเปˆเบฒเบเบฑเบšเบ„เปˆเบฒเบ—เบตเปˆเปƒเบซเป‰.

เปƒเบ™เบ„เปเบฒเบชเบฑเบšเบ•เปˆเบฒเบ‡เป†เบญเบทเปˆเบ™เป†, เบกเบตเบชเบญเบ‡เบˆเปเบฒเบ™เบงเบ™เบขเบนเปˆเปƒเบ™ array, x เปเบฅเบฐ y, เบ—เบตเปˆเป€เบกเบทเปˆเบญเบฅเบงเบกเป€เบ‚เบปเป‰เบฒเบเบฑเบ™เป€เบ—เบปเปˆเบฒเบเบฑเบšเบ„เปˆเบฒเบ—เบตเปˆเบเปเบฒเบ™เบปเบ”เป„เบงเป‰เบšเป?

เบ•เบปเบงเบขเปˆเบฒเบ‡ A

เบ–เป‰เบฒเบžเบงเบเป€เบฎเบปเบฒเป„เบ”เป‰เบฎเบฑเบš array [1, 2, 4, 9] เปเบฅเบฐเบ„เปˆเบฒเปเบกเปˆเบ™ 8, เบŸเบฑเบ‡เบŠเบฑเบ™เบˆเบฐเบเบฑเบšเบ„เบทเบ™ false เป€เบžเบฒเบฐเบงเปˆเบฒเบšเปเปˆเบกเบตเบชเบญเบ‡เบ•เบปเบงเป€เบฅเบเปƒเบ™ array เบชเบฒเบกเบฒเบ”เป€เบžเบตเปˆเบกเป„เบ”เป‰เป€เบ–เบดเบ‡ 8.

เบ•เบปเบงเบขเปˆเบฒเบ‡ B

เปเบ•เปˆเบ–เป‰เบฒเบกเบฑเบ™เป€เบ›เบฑเบ™ array [1, 2, 4, 4] เปเบฅเบฐเบ„เปˆเบฒเปเบกเปˆเบ™ 8, เบŸเบฑเบ‡เบŠเบฑเบ™เบ„เบงเบ™เบเบฑเบšเบ„เบทเบ™เบ„เบงเบฒเบกเบˆเบดเบ‡เป€เบžเบฒเบฐเบงเปˆเบฒ 4 + 4 = 8.

เบเบฒเบ™โ€‹เปเบเป‰โ€‹เป„เบ‚ 1โ€‹: เบœเบปเบ™โ€‹เบšเบฑเบ‡โ€‹เบ„เบฑเบšโ€‹เปƒเบŠเป‰ Bruteโ€‹

เบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เป€เบงเบฅเบฒ: O(Nยฒ).
เบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เบŠเปˆเบญเบ‡: O(1).

เบ„เบงเบฒเบกเบซเบกเบฒเบเบ—เบตเปˆเบŠเบฑเบ”เป€เบˆเบ™เบ—เบตเปˆเบชเบธเบ”เปเบกเปˆเบ™เบเบฒเบ™เบ™เปเบฒเปƒเบŠเป‰เบ„เบนเปˆเบ‚เบญเบ‡ loops เบฎเบฑเบ‡.

const findSum = (arr, val) => {
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr.length; j++) {
      if (i !== j && arr[i] + arr[j] === val) {
        return true;
      };
    };
  };
  return false;
};

เบเบฒเบ™เปเบเป‰เป„เบ‚เบ™เบตเป‰เบšเปเปˆเบกเบตเบ›เบฐเบชเบดเบ”เบ—เบดเบžเบฒเบšเป€เบžเบฒเบฐเบงเปˆเบฒเบกเบฑเบ™เบเบงเบ”เป€เบšเบดเปˆเบ‡เบ—เบธเบเป†เบœเบปเบ™เบฅเบงเบกเบ—เบตเปˆเป€เบ›เบฑเบ™เป„เบ›เป„เบ”เป‰เบ‚เบญเบ‡เบชเบญเบ‡เบญเบปเบ‡เบ›เบฐเบเบญเบšเปƒเบ™เบญเบฒเป€เบฃเปเบฅเบฐเบเบฑเบ‡เบ›เบฝเบšเบ—เบฝเบšเบ—เบธเบเบ„เบนเปˆเบ‚เบญเบ‡เบ”เบฑเบ”เบŠเบฐเบ™เบตเบชเบญเบ‡เบ„เบฑเป‰เบ‡. (เบ•เบปเบงเบขเปˆเบฒเบ‡, เป€เบกเบทเปˆเบญ i = 1 เปเบฅเบฐ j = 2 เบ•เบปเบงเบˆเบดเบ‡เปเบฅเป‰เบงเปเบกเปˆเบ™เบ„เบทเบเบฑเบ™เบเบฑเบšเบเบฒเบ™เบ›เบฝเบšเบ—เบฝเบšเบเบฑเบš i = 2 เปเบฅเบฐ j = 1, เปเบ•เปˆเปƒเบ™เบเบฒเบ™เปเบเป‰เป„เบ‚เบ™เบตเป‰เบžเบงเบเป€เบฎเบปเบฒเบžเบฐเบเบฒเบเบฒเบกเบ—เบฑเบ‡เบชเบญเบ‡เบ—เบฒเบ‡เป€เบฅเบทเบญเบ).

เป€เบ™เบทเปˆเบญเบ‡เบˆเบฒเบเบงเปˆเบฒเป‚เบŠเบฅเบนเบŠเบฑเปˆเบ™เบ‚เบญเบ‡เบžเบงเบเป€เบฎเบปเบฒเปƒเบŠเป‰เบ„เบนเปˆเบ—เบตเปˆเบŠเป‰เบญเบ™เบเบฑเบ™เบชเปเบฒเบฅเบฑเบš loops, เบกเบฑเบ™เป€เบ›เบฑเบ™เบชเบตเปˆเบซเบฅเปˆเบฝเบกเบ—เบตเปˆเบกเบตเบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เป€เบงเบฅเบฒ O(Nยฒ).


เบเบฒเบ™เปเบเป‰เป„เบ‚ 2: เบ„เบปเป‰เบ™เบซเบฒเบ–เบฒเบ™เบชเบญเบ‡

เบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เป€เบงเบฅเบฒ: O(Nlog(N)).
เบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เบญเบฒเบงเบฐเบเบฒเบ”: O(1)
.

เบ™เบฑเบšเบ•เบฑเป‰เบ‡เปเบ•เปˆ arrays เบ–เบทเบเบˆเบฑเบ”เบฅเปเบฒเบ”เบฑเบš, เบžเบงเบเป€เบฎเบปเบฒเบชเบฒเบกเบฒเบ”เบ„เบปเป‰เบ™เบซเบฒเบเบฒเบ™เปเบเป‰เป„เบ‚เป‚เบ”เบเปƒเบŠเป‰ binary search. เบ™เบตเป‰เปเบกเปˆเบ™เบชเบนเบ”เบเบฒเบ™เบ„เบดเบ”เป„เบฅเปˆเบ—เบตเปˆเบกเบตเบ›เบฐเบชเบดเบ”เบ—เบดเบžเบฒเบšเบ—เบตเปˆเบชเบธเบ”เบชเปเบฒเบฅเบฑเบš arrays เบ—เบตเปˆเบชเบฑเปˆเบ‡. เบเบฒเบ™เบ„เบปเป‰เบ™เบซเบฒ Binary เบ•เบปเบงเบ‚เบญเบ‡เบกเบฑเบ™เป€เบญเบ‡เบกเบตเป€เบงเบฅเบฒเปเบฅเปˆเบ™เบ‚เบญเบ‡ O(log(N)). เบขเปˆเบฒเบ‡เปƒเบ”เบเปเบ•เบฒเบก, เบ—เปˆเบฒเบ™เบเบฑเบ‡เบˆเปเบฒเป€เบ›เบฑเบ™เบ•เป‰เบญเบ‡เปƒเบŠเป‰ a for loop เป€เบžเบทเปˆเบญเบเบงเบ”เป€เบšเบดเปˆเบ‡เปเบ•เปˆเบฅเบฐเบญเบปเบ‡เบ›เบฐเบเบญเบšเบ—เบฝเบšเบเบฑเบšเบ„เปˆเบฒเบญเบทเปˆเบ™เป†เบ—เบฑเบ‡เบซเบกเบปเบ”.

เบ™เบตเป‰เปเบกเปˆเบ™เบชเบดเปˆเบ‡เบ—เบตเปˆเบเบฒเบ™เปเบเป‰เป„เบ‚เบญเบฒเบ”เบˆเบฐเป€เบšเบดเปˆเบ‡เบ„เบทเบงเปˆเบฒ. เป€เบžเบทเปˆเบญเป€เบฎเบฑเบ”เปƒเบซเป‰เบชเบดเปˆเบ‡เบ—เบตเปˆเบŠเบฑเบ”เป€เบˆเบ™, เบžเบงเบเป€เบฎเบปเบฒเปƒเบŠเป‰เบŸเบฑเบ‡เบŠเบฑเบ™เปเบเบเบ•เปˆเบฒเบ‡เบซเบฒเบเป€เบžเบทเปˆเบญเบ„เบงเบšเบ„เบธเบกเบเบฒเบ™เบ„เบปเป‰เบ™เบซเบฒเบ„เบนเปˆ. เปเบฅเบฐเบเบฑเบ‡เบŸเบฑเบ‡เบŠเบฑเบ™ removeIndex() เป€เบŠเบดเปˆเบ‡เบชเบปเปˆเบ‡เบ„เบทเบ™เป€เบงเบตเบŠเบฑเบ™เบ‚เบญเบ‡ array เบฅเบปเบšเบ”เบฑเบ”เบŠเบฐเบ™เบตเบ—เบตเปˆเปƒเบซเป‰.

const findSum = (arr, val) => {
  for (let i = 0; i < arr.length; i++){
    if (binarySearch(removeIndex(arr, i), val - arr[i])) {
      return true;
    }
  };
  return false;
};
 
const removeIndex = (arr, i) => {
  return arr.slice(0, i).concat(arr.slice(i + 1, arr.length));
};
 
const binarySearch = (arr, val) => {
  let start = 0;
  let end = arr.length - 1;
  let pivot = Math.floor(arr.length / 2); 
  while (start < end) {
    if (val < arr[pivot]) {
      end = pivot - 1;
    } else if (val > arr[pivot]) {
      start = pivot + 1;
    };
    pivot = Math.floor((start + end) / 2);
    if (arr[pivot] === val) {
      return true;
    }
  };
  return false;
};

เบชเบนเบ”เบเบฒเบ™เบ„เบดเบ”เป„เบฅเปˆเป€เบฅเบตเปˆเบกเบ•เบปเป‰เบ™เบˆเบฒเบเบ”เบฑเบ”เบŠเบฐเบ™เบต [0]. เบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™, เบกเบฑเบ™เบชเป‰เบฒเบ‡เบชเบฐเบšเบฑเบšเบ‚เบญเบ‡ array เบ—เบตเปˆเบšเปเปˆเบฅเบงเบกเป€เบญเบปเบฒเบ”เบฑเบ”เบชเบฐเบ™เบตเบ—เปเบฒเบญเบดเบ”เปเบฅเบฐเปƒเบŠเป‰เบเบฒเบ™เบ„เบปเป‰เบ™เบซเบฒเบ„เบนเปˆเป€เบžเบทเปˆเบญเป€เบšเบดเปˆเบ‡เบงเปˆเบฒเบ„เปˆเบฒเปƒเบ”เป†เบ—เบตเปˆเบเบฑเบ‡เป€เบซเบผเบทเบญเบชเบฒเบกเบฒเบ”เบ–เบทเบเป€เบžเบตเปˆเบกเปƒเบชเปˆ array เป€เบžเบทเปˆเบญเบœเบฐเบฅเบดเบ”เบœเบปเบ™เบฅเบงเบกเบ—เบตเปˆเบ•เป‰เบญเบ‡เบเบฒเบ™. เบ„เบณเบชเบฑเปˆเบ‡เบ™เบตเป‰เบ–เบทเบเบ›เบฐเบ•เบดเบšเบฑเบ”เบ„เบฑเป‰เบ‡เบ”เบฝเบงเบชเบณเบฅเบฑเบšเปเบ•เปˆเบฅเบฐเบญเบปเบ‡เบ›เบฐเบเบญเบšเปƒเบ™เบญเบฒเป€เบฃ.

The for loop เบ•เบปเบงเบ‚เบญเบ‡เบกเบฑเบ™เป€เบญเบ‡เบˆเบฐเบกเบตเบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เป€เบงเบฅเบฒ linear เบ‚เบญเบ‡ O(N), เปเบ•เปˆเบžเบฒเบเปƒเบ™ for loop เบžเบงเบเป€เบฎเบปเบฒเบ”เปเบฒเป€เบ™เบตเบ™เบเบฒเบ™เบ„เบปเป‰เบ™เบซเบฒเบ„เบนเปˆ, เป€เบŠเบดเปˆเบ‡เป€เบฎเบฑเบ”เปƒเบซเป‰เบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เป€เบงเบฅเบฒเป‚เบ”เบเบฅเบงเบกเบ‚เบญเบ‡ O(Nlog(N)). เบเบฒเบ™โ€‹เปเบเป‰โ€‹เป„เบ‚โ€‹เบ™เบตเป‰โ€‹เปเบกเปˆเบ™โ€‹เบ”เบตเบโ€‹เปˆโ€‹เบงเบฒโ€‹เบ—เบตเปˆโ€‹เบœเปˆเบฒเบ™โ€‹เบกเบฒโ€‹, เปเบ•เปˆโ€‹เบงเปˆเบฒโ€‹เบเบฑเบ‡โ€‹เบกเบตโ€‹เบซเป‰เบญเบ‡โ€‹เบชเปเบฒโ€‹เบฅเบฑเบšโ€‹เบเบฒเบ™โ€‹เบ›เบฑเบšโ€‹เบ›เบธเบ‡โ€‹.


เบเบฒเบ™เปเบเป‰เป„เบ‚ 3: เป€เบงเบฅเบฒเป€เบชเบฑเป‰เบ™

เบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เป€เบงเบฅเบฒ: O(N).
เบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เบŠเปˆเบญเบ‡: O(1).

เปƒเบ™เบ›เบฑเบ”เบˆเบธเบšเบฑเบ™เบžเบงเบเป€เบฎเบปเบฒเบˆเบฐเปเบเป‰เป„เบ‚เบšเบฑเบ™เบซเบฒ, เบˆเบทเปˆเบˆเปเบฒเบงเปˆเบฒ array เบ–เบทเบเบˆเบฑเบ”เบฎเบฝเบ‡. เบเบฒเบ™โ€‹เปเบเป‰โ€‹เป„เบ‚โ€‹เปเบกเปˆเบ™โ€‹เบˆเบฐโ€‹เป€เบญเบปเบฒโ€‹เบชเบญเบ‡โ€‹เบ•เบปเบงโ€‹เป€เบฅเบโ€‹: เบซเบ™เบถเปˆเบ‡โ€‹เปƒเบ™โ€‹เบ•เบญเบ™โ€‹เบ•เบปเป‰เบ™โ€‹เปเบฅเบฐโ€‹เบซเบ™เบถเปˆเบ‡โ€‹เปƒเบ™โ€‹เบ•เบญเบ™โ€‹เบ—เป‰เบฒเบโ€‹. เบ–เป‰เบฒเบœเบปเบ™เป„เบ”เป‰เบฎเบฑเบšเปเบ•เบเบ•เปˆเบฒเบ‡เบˆเบฒเบเบญเบฑเบ™เบ—เบตเปˆเบ•เป‰เบญเบ‡เบเบฒเบ™, เบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™เปƒเบซเป‰เบ›เปˆเบฝเบ™เบˆเบธเบ”เป€เบฅเบตเปˆเบกเบ•เบปเป‰เบ™เปเบฅเบฐเบˆเบธเบ”เบชเบดเป‰เบ™เบชเบธเบ”.

เปƒเบ™โ€‹เบ—เบตเปˆโ€‹เบชเบธเบ”โ€‹เบžเบงเบโ€‹เป€เบฎเบปเบฒโ€‹เบˆเบฐโ€‹เบžเบปเบšโ€‹เบเบฑเบšโ€‹เบ„เปˆเบฒโ€‹เบ—เบตเปˆโ€‹เบ•เป‰เบญเบ‡โ€‹เบเบฒเบ™โ€‹เปเบฅเบฐโ€‹เบเบฑเบšโ€‹เบ„เบทเบ™โ€‹เบกเบฒโ€‹เป€เบ›เบฑเบ™โ€‹เบ„เบงเบฒเบกโ€‹เบˆเบดเบ‡โ€‹, เบซเบผเบทโ€‹เบˆเบธเบ”โ€‹เป€เบฅเบตเปˆเบกโ€‹เบ•เบปเป‰เบ™โ€‹เปเบฅเบฐโ€‹เบˆเบธเบ”โ€‹เบชเบดเป‰เบ™โ€‹เบชเบธเบ”โ€‹เบˆเบฐ converge เปเบฅเบฐโ€‹เบเบฑเบšโ€‹เบ„เบทเบ™โ€‹เบกเบฒโ€‹เป€เบ›เบฑเบ™โ€‹เบœเบดเบ”โ€‹.

const findSum = (arr, val) => {
  let start = 0;
  let end = arr.length - 1;
  while (start < end) {
    let sum = arr[start] + arr[end];
    if (sum > val) {
      end -= 1;
    } else if (sum < val) {
      start += 1;
    } else {
      return true;
    };
  };
  return false;
};


เปƒเบ™เบ›เบฑเบ”เบˆเบธเบšเบฑเบ™เบ—เบธเบเบชเบดเปˆเบ‡เบ—เบธเบเบขเปˆเบฒเบ‡เปเบกเปˆเบ™เบ”เบต, เบเบฒเบ™เปเบเป‰เป„เบ‚เป€เบšเบดเปˆเบ‡เบ„เบทเบงเปˆเบฒเบ”เบตเบ—เบตเปˆเบชเบธเบ”. เปเบ•เปˆเปƒเบœเบชเบฒเบกเบฒเบ”เบฎเบฑเบšเบ›เบฐเบเบฑเบ™เบงเปˆเบฒ array เป„เบ”เป‰เบ–เบทเบเบชเบฑเปˆเบ‡?

เปเบฅเป‰เบงเปเบกเปˆเบ™เบซเบเบฑเบ‡?

เบขเบนเปˆ glance เบ—เปเบฒเบญเบดเบ”, เบžเบงเบเป€เบฎเบปเบฒเบชเบฒเบกเบฒเบ”เบชเบฑเปˆเบ‡เบžเบฝเบ‡เปเบ•เปˆ array เบ—เปเบฒเบญเบดเบ”เปเบฅเบฐเบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™เบ™เปเบฒเปƒเบŠเป‰เบเบฒเบ™เปเบเป‰เป„เบ‚เบ‚เป‰เบฒเบ‡เป€เบ—เบดเบ‡. เปเบ•เปˆเบ™เบตเป‰เบˆเบฐเบกเบตเบœเบปเบ™เบเบฐเบ—เบปเบšเปเบ™เบงเปƒเบ”เบ•เปเปˆเป€เบงเบฅเบฒเบ›เบฐเบ•เบดเบšเบฑเบ”?

เบชเบนเบ”เบเบฒเบ™เบ„เบดเบ”เป„เบฅเปˆเบ—เบตเปˆเบ”เบตเบ—เบตเปˆเบชเบธเบ”เปเบกเปˆเบ™เบˆเบฑเบ”เบฎเบฝเบ‡เป„เบงเบเบฑเบšเบ„เบงเบฒเบกเบชเบฑเบšเบชเบปเบ™เป€เบงเบฅเบฒ O (Nlog (N)). เบ–เป‰เบฒเบžเบงเบเป€เบฎเบปเบฒเปƒเบŠเป‰เบกเบฑเบ™เปƒเบ™เบเบฒเบ™เปเบเป‰เป„เบ‚เบ—เบตเปˆเบ”เบตเบ—เบตเปˆเบชเบธเบ”เบ‚เบญเบ‡เบžเบงเบเป€เบฎเบปเบฒ, เบกเบฑเบ™เบˆเบฐเบ›เปˆเบฝเบ™เบ›เบฐเบชเบดเบ”เบ—เบดเบžเบฒเบšเบ‚เบญเบ‡เบกเบฑเบ™เบˆเบฒเบ O(N) เป„เบ› O(Nlog(N)). เบกเบฑเบ™เป€เบ›เบฑเบ™เป„เบ›เป„เบ”เป‰เบ—เบตเปˆเบˆเบฐเบŠเบญเบเบซเบฒเบงเบดเบ—เบตเปเบเป‰เป„เบ‚ linear เบเบฑเบš array unordered?

4 Solution

เบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เป€เบงเบฅเบฒ: O(N).
เบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เบŠเปˆเบญเบ‡: O(N).

เปเบกเปˆเบ™เปเบฅเป‰เบง, เบกเบตเบเบฒเบ™เปเบเป‰เป„เบ‚เป€เบชเบฑเป‰เบ™เบŠเบทเปˆ; เป€เบžเบทเปˆเบญเป€เบฎเบฑเบ”เบชเบดเปˆเบ‡เบ™เบตเป‰, เบžเบงเบเป€เบฎเบปเบฒเบˆเปเบฒเป€เบ›เบฑเบ™เบ•เป‰เบญเบ‡เบชเป‰เบฒเบ‡ array เปƒเบซเบกเปˆเบ—เบตเปˆเบกเบตเบšเบฑเบ™เบŠเบตเบฅเบฒเบเบŠเบทเปˆเบ‚เบญเบ‡เบเบฒเบ™เปเบ‚เปˆเบ‡เบ‚เบฑเบ™เบ—เบตเปˆเบžเบงเบเป€เบฎเบปเบฒเบเปเบฒเบฅเบฑเบ‡เบŠเบญเบเบซเบฒ. เบเบฒเบ™เปเบฅเบเบ›เปˆเบฝเบ™เบ™เบตเป‰เปเบกเปˆเบ™เบเบฒเบ™เปƒเบŠเป‰เบ„เบงเบฒเบกเบŠเบปเบ‡เบˆเปเบฒเบซเบผเบฒเบเบเบงเปˆเบฒเป€เบเบปเปˆเบฒ: เบกเบฑเบ™เป€เบ›เบฑเบ™เบเบฒเบ™เปเบเป‰เป„เบ‚เบžเบฝเบ‡เปเบ•เปˆเปƒเบ™เป€เบˆเป‰เบเบ—เบตเปˆเบกเบตเบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เบŠเปˆเบญเบ‡เบซเบผเบฒเบเบเบงเปˆเบฒ O(1).

เบ–เป‰เบฒเบ„เปˆเบฒเบ—เปเบฒเบญเบดเบ”เบ‚เบญเบ‡เบญเบฒเป€เบฃเบ—เบตเปˆเปƒเบซเป‰เปเบกเปˆเบ™ 1 เปเบฅเบฐเบ„เปˆเบฒเบ„เบปเป‰เบ™เบซเบฒเปเบกเปˆเบ™ 8, เบžเบงเบเป€เบฎเบปเบฒเบชเบฒเบกเบฒเบ”เป€เบžเบตเปˆเบกเบ„เปˆเบฒ 7 เปƒเบซเป‰เบเบฑเบšเบญเบฒเป€เบฃ "เบ„เปˆเบฒเบ„เบปเป‰เบ™เบซเบฒ".

เบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™, เป€เบกเบทเปˆเบญเบžเบงเบเป€เบฎเบปเบฒเบ›เบธเบ‡เปเบ•เปˆเบ‡เปเบ•เปˆเบฅเบฐเบญเบปเบ‡เบ›เบฐเบเบญเบšเบ‚เบญเบ‡เบญเบฒเป€เบฅ, เบžเบงเบเป€เบฎเบปเบฒเบชเบฒเบกเบฒเบ”เบเบงเบ”เป€เบšเบดเปˆเบ‡ array เบ‚เบญเบ‡ "เบ„เปˆเบฒเบ„เบปเป‰เบ™เบซเบฒ" เปเบฅเบฐเป€เบšเบดเปˆเบ‡เบงเปˆเบฒเบซเบ™เบถเปˆเบ‡เปƒเบ™เบ™เบฑเป‰เบ™เป€เบ—เบปเปˆเบฒเบเบฑเบšเบกเบนเบ™เบ„เปˆเบฒเบ‚เบญเบ‡เบžเบงเบเป€เบฎเบปเบฒ. เบ–เป‰เบฒเปเบกเปˆเบ™, เบเบฑเบšเบ„เบทเบ™เบ„เบงเบฒเบกเบˆเบดเบ‡.

const findSum = (arr, val) => {
  let searchValues = [val - arr[0]];
  for (let i = 1; i < arr.length; i++) {
    let searchVal = val - arr[i];
    if (searchValues.includes(arr[i])) {
      return true;
    } else {
      searchValues.push(searchVal);
    }
  };
  return false;
};

เบžเบทเป‰เบ™เบ–เบฒเบ™เบ‚เบญเบ‡เบเบฒเบ™เปเบเป‰เป„เบ‚เปเบกเปˆเบ™เบชเปเบฒเบฅเบฑเบš loop, เป€เบŠเบดเปˆเบ‡, เบ”เบฑเปˆเบ‡เบ—เบตเปˆเบžเบงเบเป€เบฎเบปเบฒเป„เบ”เป‰เป€เบซเบฑเบ™เบ‚เป‰เบฒเบ‡เป€เบ—เบดเบ‡, เบกเบตเบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เป€เบงเบฅเบฒเป€เบชเบฑเป‰เบ™เบŠเบทเปˆเบ‚เบญเบ‡ O(N).

เบžเบฒเบเบชเปˆเบงเบ™เบ—เบตเปˆเบŠเปเป‰เบฒเบเบฑเบ™เบ—เบตเบชเบญเบ‡เบ‚เบญเบ‡เบŸเบฑเบ‡เบŠเบฑเบ™เบ‚เบญเบ‡เบžเบงเบเป€เบฎเบปเบฒเปเบกเปˆเบ™ Array.prototype.include(), เบงเบดเบ—เบตเบเบฒเบ™ JavaScript เบ—เบตเปˆเบˆเบฐเบชเบปเปˆเบ‡เบ„เบทเบ™เบ„เบงเบฒเบกเบˆเบดเบ‡ เบซเบผเบทเบœเบดเบ” เบ‚เบถเป‰เบ™เบเบฑเบšเบงเปˆเบฒเบญเบฒเป€เบฃเบกเบตเบ„เปˆเบฒเบ—เบตเปˆเปƒเบซเป‰เป„เบงเป‰เบซเบผเบทเบšเปเปˆ.

เป€เบžเบทเปˆเบญเบ„เบดเบ”เป„เบฅเปˆเบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เป€เบงเบฅเบฒเบ‚เบญเบ‡ Array.prototype.includes(), เบžเบงเบเป€เบฎเบปเบฒเบชเบฒเบกเบฒเบ”เป€เบšเบดเปˆเบ‡ polyfill เบ—เบตเปˆเบชเบฐเบซเบ™เบญเบ‡เปƒเบซเป‰เป‚เบ”เบ MDN (เปเบฅเบฐเบ‚เบฝเบ™เปƒเบ™ JavaScript) เบซเบผเบทเปƒเบŠเป‰เบงเบดเบ—เบตเบเบฒเบ™เปƒเบ™เบฅเบฐเบซเบฑเบ”เปเบซเบผเปˆเบ‡เบ‚เบญเบ‡เป€เบ„เบทเปˆเบญเบ‡เบˆเบฑเบ JavaScript เป€เบŠเบฑเปˆเบ™ Google V8 (C++).

// https://tc39.github.io/ecma262/#sec-array.prototype.includes
if (!Array.prototype.includes) {
  Object.defineProperty(Array.prototype, 'includes', {
    value: function(valueToFind, fromIndex) {
 
      if (this == null) {
        throw new TypeError('"this" is null or not defined');
      }
 
      // 1. Let O be ? ToObject(this value).
      var o = Object(this);
 
      // 2. Let len be ? ToLength(? Get(O, "length")).
      var len = o.length >>> 0;
 
      // 3. If len is 0, return false.
      if (len === 0) {
        return false;
      }
 
      // 4. Let n be ? ToInteger(fromIndex).
      //    (If fromIndex is undefined, this step produces the value 0.)
      var n = fromIndex | 0;
 
      // 5. If n โ‰ฅ 0, then
      //  a. Let k be n.
      // 6. Else n < 0,
      //  a. Let k be len + n.
      //  b. If k < 0, let k be 0.
      var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
 
      function sameValueZero(x, y) {
        return x === y || (typeof x === 'number' && typeof y === 'number' && isNaN(x) && isNaN(y));
      }
 
      // 7. Repeat, while k < len
      while (k < len) {
        // a. Let elementK be the result of ? Get(O, ! ToString(k)).
        // b. If SameValueZero(valueToFind, elementK) is true, return true.
        if (sameValueZero(o[k], valueToFind)) {
          return true;
        }
        // c. Increase k by 1.
        k++;
      }
 
      // 8. Return false
      return false;
    }
  });
}

เบ•เปเปˆเป„เบ›เบ™เบตเป‰เปเบกเปˆเบ™เบชเปˆเบงเบ™เบ—เบตเปˆเบŠเป‰เบณเบเบฑเบ™เบ‚เบญเบ‡ Array.prototype.include() เปเบกเปˆเบ™เบเบฒเบ™ loop เปƒเบ™เบ‚เบฑเป‰เบ™เบ•เบญเบ™เบ—เบต 7 เบ—เบตเปˆ (เป€เบเบทเบญเบš) เบ‚เป‰เบฒเบกเบ„เบงเบฒเบกเบเบฒเบงเบ—เบฑเบ‡เปเบปเบ”เบ‚เบญเบ‡เบญเบฒเป€เบฃเบ—เบตเปˆเปƒเบซเป‰. เบ™เบตเป‰เบซเบกเบฒเบเบ„เบงเบฒเบกเบงเปˆเบฒเบ„เบงเบฒเบกเบชเบฑเบšเบชเบปเบ™เบ—เบตเปˆเปƒเบŠเป‰เป€เบงเบฅเบฒเบ‚เบญเบ‡เบกเบฑเบ™เบเบฑเบ‡เป€เบ›เบฑเบ™เป€เบชเบฑเป‰เบ™. เบ”เบต, เป€เบ™เบทเปˆเบญเบ‡เบˆเบฒเบเบงเปˆเบฒเบกเบฑเบ™เบชเบฐเป€เบซเบกเบตเบซเบ™เบถเปˆเบ‡เบ‚เบฑเป‰เบ™เบ•เบญเบ™เบ—เบฒเบ‡เบซเบฅเบฑเบ‡เบ‚เบญเบ‡เบญเบฒเป€เบฅเบ•เบปเป‰เบ™เบ•เปเบ‚เบญเบ‡เบžเบงเบเป€เบฎเบปเบฒ, เบ„เบงเบฒเบกเบชเบฑเบšเบชเบปเบ™เป€เบงเบฅเบฒเปเบกเปˆเบ™ O (N + (N - 1)). เบเบฒเบ™เบ™เปเบฒเปƒเบŠเป‰ Big O Notation, เบžเบงเบเป€เบฎเบปเบฒเป€เบฎเบฑเบ”เปƒเบซเป‰เบกเบฑเบ™เบ‡เปˆเบฒเบเป€เบ›เบฑเบ™ O(N) - เป€เบžเบฒเบฐเบงเปˆเบฒเบกเบฑเบ™เป€เบ›เบฑเบ™ N เบ—เบตเปˆเบกเบตเบœเบปเบ™เบเบฐเบ—เบปเบšเบ—เบตเปˆเบชเบธเบ”เปƒเบ™เป€เบงเบฅเบฒเบ—เบตเปˆเป€เบžเบตเปˆเบกเบ‚เบฐเบซเบ™เบฒเบ”เบเบฒเบ™เบ›เป‰เบญเบ™เบ‚เปเป‰เบกเบนเบ™.

เบเปˆเบฝเบงเบเบฑเบšเบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เบ—เบฒเบ‡เบเบงเป‰เบฒเบ‡เบ‚เบญเบ‡เบžเบทเป‰เบ™เบ—เบตเปˆ, เบˆเปเบฒเป€เบ›เบฑเบ™เบ•เป‰เบญเบ‡เบกเบตเบญเบฒเป€เบฃเป€เบžเบตเปˆเบกเป€เบ•เบตเบกเบ—เบตเปˆเบ„เบงเบฒเบกเบเบฒเบงเบชเบฐเบ—เป‰เบญเบ™เบเบฑเบšเบญเบฒเป€เบฃเบ•เบปเป‰เบ™เบชเบฐเบšเบฑเบš (เบฅเบปเบšเบซเบ™เบถเปˆเบ‡, เปเบกเปˆเบ™เปเบฅเป‰เบง, เปเบ•เปˆเบงเปˆเบฒเบชเบฒเบกเบฒเบ”เบ–เบทเบเบฅเบฐเป€เบฅเบตเบ), เบชเบปเปˆเบ‡เบœเบปเบ™เปƒเบซเป‰ O(N) เบชเบฐเบฅเบฑเบšเบชเบฑเบšเบŠเป‰เบญเบ™. เบ”เบต, เบเบฒเบ™เบ™เปเบฒเปƒเบŠเป‰เบ„เบงเบฒเบกเบŠเบปเบ‡เบˆเปเบฒเบ—เบตเปˆเป€เบžเบตเปˆเบกเบ‚เบถเป‰เบ™เบฎเบฑเบšเบ›เบฐเบเบฑเบ™เบ›เบฐเบชเบดเบ”เบ—เบดเบžเบฒเบšเบชเบนเบ‡เบชเบธเบ”เบ‚เบญเบ‡เบชเบนเบ”เบเบฒเบ™เบ„เบดเบ”เป„เบฅเปˆ.


เบ‚เป‰เบฒโ€‹เบžเบฐโ€‹เป€เบˆเบปเป‰เบฒโ€‹เบซเบงเบฑเบ‡โ€‹เบงเปˆเบฒโ€‹เบ—เปˆเบฒเบ™โ€‹เบˆเบฐโ€‹เบŠเบญเบโ€‹เบซเบฒโ€‹เบšเบปเบ”โ€‹เบ„เบงเบฒเบกโ€‹เบ—เบตเปˆโ€‹เป€เบ›เบฑเบ™โ€‹เบ›เบฐโ€‹เป‚เบซเบเบ”โ€‹เป€เบ›เบฑเบ™โ€‹เบเบฒเบ™โ€‹เป€เบชเบตเบกโ€‹เบชเปเบฒโ€‹เบฅเบฑเบšโ€‹เบเบฒเบ™โ€‹เบชเปเบฒโ€‹เบžเบฒเบ”โ€‹เบงเบดโ€‹เบ”เบตโ€‹เป‚เบญโ€‹เบ‚เบญเบ‡โ€‹เบ—เปˆเบฒเบ™โ€‹. เบกเบฑเบ™เบชเบฐเปเบ”เบ‡เปƒเบซเป‰เป€เบซเบฑเบ™เบงเปˆเบฒเบšเบฑเบ™เบซเบฒเบ—เบตเปˆเบ‡เปˆเบฒเบเบ”เบฒเบเบชเบฒเบกเบฒเบ”เปเบเป‰เป„เบ‚เป„เบ”เป‰เปƒเบ™เบซเบผเบฒเบเบงเบดเบ—เบตเบ—เบตเปˆเปเบ•เบเบ•เปˆเบฒเบ‡เบเบฑเบ™เบ”เป‰เบงเบเบ›เบฐเบฅเบดเบกเบฒเบ™เบ—เบตเปˆเปเบ•เบเบ•เปˆเบฒเบ‡เบเบฑเบ™เบ‚เบญเบ‡เบŠเบฑเบšเบžเบฐเบเบฒเบเบญเบ™เบ—เบตเปˆเปƒเบŠเป‰ (เป€เบงเบฅเบฒ, เบ„เบงเบฒเบกเบˆเปเบฒ).

Skillbox เปเบ™เบฐเบ™เปเบฒ:

เปเบซเบผเปˆเบ‡เบ‚เปเป‰เบกเบนเบ™: www.habr.com

เป€เบžเบตเปˆเบกเบ„เบงเบฒเบกเบ„เบดเบ”เป€เบซเบฑเบ™