/**
* @param {string} haystack
* @param {string} needle
* @return {number}
*/
var strStr = function (haystack, needle) {
return haystack.indexOf(needle)
};
2024/07/23
LeetCode 28. Find the Index of the First Occurrence in a String
2024/07/19
LeetCode 3131. Find the Integer Added to Array I
/**
* @param {number[]} nums1
* @param {number[]} nums2
* @return {number}
*/
var addedInteger = function (nums1, nums2) {
if (nums1.length < 1 || nums2.length > 100 || nums1.length !== nums2.length) {
return 0
}
const sum = (p, c) => p + c
const sum1 = nums1.reduce(sum)
const sum2 = nums2.reduce(sum)
const total = sum2 > sum1 ? sum2 - sum1 : -(sum1 - sum2)
return (total % nums1.length) === 0 ? total / nums1.length : 0
};
2024/07/18
LeetCode 1920. Build Array from Permutation
/**
* @param {number[]} nums
* @return {number[]}
*/
var buildArray = function (nums) {
if (nums.length < 1 || nums.length > 1000) {
return []
}
const result = []
nums.forEach((_, i) => result.push(nums[nums[i]]))
return result
};LeetCode 3110. Score of a String
/**
* @param {string} s
* @return {number}
*/
var scoreOfString = function (s) {
if (s.length < 2 || s.length > 100) {
return 0
}
let sum = 0
let j = 1
for (let i = 0; i < s.length - 1; i++) {
sum += Math.abs(s[i].charCodeAt(0) - s[j++].charCodeAt(0))
}
return sum
};LeetCode 2727. Is Object Empty
/**
* @param {Object|Array} obj
* @return {boolean}
*/
var isEmpty = function (obj) {
if (obj instanceof Object)
return !obj || Object.keys(obj).length === 0
else if (obj instanceof Array)
return !obj || obj.length === 0
};LeetCode 2652. Sum Multiples
/**
* @param {number} n
* @return {number}
*/
var sumOfMultiples = function (n) {
if (n < 1 || n > Math.pow(10, 3)) {
return 0
}
let sum = 0
const ary = Array.from({length: n}, (_, i) => i + 1)
ary.forEach(i => {
if (i % 3 === 0 || i % 5 === 0 || i % 7 === 0) {
sum += i
}
})
return sum
};LeetCode 2000. Reverse Prefix of Word
/**
* @param {string} word
* @param {character} ch
* @return {string}
*/
var reversePrefix = function (word, ch) {
if (word.length < 1 || word.length > 250) {
return ""
}
const index = word.indexOf(ch)
if (index === -1) {
return word
} else {
const revertStr = word.substring(0, index + 1)
const lastStr = word.substring(index + 1)
let newString = ""
for (let i = revertStr.length - 1; i >= 0; i--) {
newString += revertStr[i]
}
return `${newString}${lastStr}`
}
};LeetCode 2894. Divisible and Non-divisible Sums Difference
/**
* @param {number} n
* @param {number} m
* @return {number}
*/
var differenceOfSums = function (n, m) {
if (n < 1 || m > 1000) {
return 0
}
const nums = Array.from({length: n}, (_, i) => i + 1)
let num1 = 0
let num2 = 0
nums.forEach(n => {
if (n % m !== 0) {
num1 += n
} else {
num2 += n
}
})
return num1 - num2
};LeetCode 1108. Defanging an IP Address
/**
* @param {string} address
* @return {string}
*/
var defangIPaddr = function (address) {
return address.replaceAll(".", "[.]")
};LeetCode 2469. Convert the Temperature
/**
* @param {number} celsius
* @return {number[]}
*/
var convertTemperature = function (celsius) {
return [
celsius + 273.15,
celsius * 1.80 + 32.00
]
};LeetCode 1929. Concatenation of Array
/**
* @param {number[]} nums
* @return {number[]}
*/
var getConcatenation = function (nums) {
if (nums.length < 1 || nums.length > 1000) {
return []
}
nums.push(...nums)
return nums
};LeetCode 2723. Add Two Promises
/**
* 接收兩個Promise，當它們都解析完成後，將它們的結果相加並返回一個新的Promise。
*
* @param {Promise} promise1 - 第一個Promise，應該解析為數值。
* @param {Promise} promise2 - 第二個Promise，應該解析為數值。
* @return {Promise} - 解析為兩個Promise結果相加的值。
*/
var addTwoPromises = async function(promise1, promise2) {
// 等待第一個Promise解析，並將結果賦值給num1
const num1 = await promise1;
// 等待第二個Promise解析，並將結果賦值給num2
const num2 = await promise2;
// 返回一個新的Promise，解析為num1和num2的和
return num1 + num2;
}; LeetCode 194. Transpose File
awk '
{
for (i=1; i<=NF; i++) {
a[i] = a[i] ? a[i] " " $i : $i
}
}
END {
for (i=1; i<=length(a); i++) {
print a[i]
}
}
' file.txtLeetCode 193. Valid Phone Numbers
grep -E "^[0-9]{3}-[0-9]{3}-[0-9]{4}$|^\([0-9]{3}\) [0-9]{3}-[0-9]{4}$" file.txtLeetCode 192. Word Frequency
tr -s '[:space:]' '\n' < words.txt | sort | uniq -c | sort -nr | awk '{print $2, $1}'
2620. Counter
/**
* @param {number} n
* @return {Function} counter
*/
var createCounter = function (n) {
return function () {
return n++
};
};
LeetCode 2621. Sleep
/**
* 暫停指定的毫秒數後返回一個 Promise
* @param {number} millis - 要暫停的毫秒數
* @return {Promise} - 一個 Promise，在指定毫秒數後 resolve，並返回經過的時間
*/
async function sleep(millis) {
// 獲取當前時間戳
const t = Date.now();
// 返回一個 Promise，該 Promise 在 setTimeout 完成後 resolve
return new Promise(resolve =>
// 設置定時器，暫停指定毫秒數後執行回調函數
setTimeout(() =>
// 在回調函數中，resolve Promise，並傳入經過的時間
resolve(Date.now() - t),
millis
)
);
}
LeetCode 258. Add Digits
/**
* 將數字各位數字相加，直到結果為一個個位數
* @param {number} num - 輸入的整數
* @return {number} - 相加結果的個位數
*/
var addDigits = function (num) {
// 檢查輸入數字是否在有效範圍內
if (num < 0 || num > Math.pow(2, 31) - 1) {
return 0;
}
// 重複相加數字的每一位，直到結果為個位數
while (num >= 10) {
// 將數字轉換為字符串
const str = num.toString();
// 將字符串分割為字符數組
const array = str.split('');
// 初始化相加結果
let result = 0;
// 遍歷字符數組，將每個字符轉換為數字並相加
array.forEach(i => result += parseInt(i));
// 更新 num 為相加結果
num = result;
}
// 返回最終結果，即個位數
return num;
};
LeetCode 169. Majority Element
/**
* 找到數組中的多數元素（即出現次數超過 n/2 的元素）
* @param {number[]} nums - 整數數組
* @return {number} - 多數元素
*/
var majorityElement = function(nums) {
// 檢查數組長度是否在有效範圍內
if (nums.length < 1 || nums.length > Math.pow(10, 4) * 5) {
return 0;
}
// 將數組按升序排序
nums = nums.sort((a, b) => a - b);
// 返回數組中間的元素，因為排序後中間的元素必定是多數元素
return nums[Math.floor(nums.length / 2)];
};
訂閱：
文章 (Atom)