var twoSum = function(nums, target) {
let index = 0
while(index < nums.length) {
let temp = nums.lastIndexOf(target - nums[index])
if(temp > index) return [index, temp]
index++
}
};
var addTwoNumbers = function(l1, l2) {
const trans = node => node.next? BigInt(node.val) + trans(node.next) * BigInt(10) : BigInt(node.val)
const sum = trans(l1) + trans(l2)
let node = new ListNode()
let ans = node
let length = sum.toString().length
sum.toString().split('').reverse().forEach((item, index) => {
node.val = Number(item)
node.next = index < length - 1? new ListNode() : null
node = node.next
})
return ans
};
var lengthOfLongestSubstring = function(s) {
if(s.length == 0) return 0
let ans = 0
let set = new Set()
let l = 0, r = 0
while(r < s.length) {
if(!set.has(s[r])) {
set.add(s[r])
ans = Math.max(ans, set.size)
}
else {
while(set.has(s[r])) {
set.delete(s[l])
l++
}
set.add(s[r])
}
r++
}
return ans
};
var findMedianSortedArrays = function(nums1, nums2) {
let nums = [...nums1, ...nums2].sort((a, b) => a - b)
let len = nums.length
let mid = Math.floor(len/2)
return len%2 == 0? (nums[mid - 1] + nums[mid])/2 : nums[mid]
};
var maxArea = function(height) {
let [l, r] = [0, height.length - 1]
let ans = 0
while(l < r) {
ans = Math.max(ans, Math.min(height[l], height[r]) * (r - l))
if(height[l] < height[r]) l++
else r--
}
return ans
};
const map = {
2: 'abc',
3: 'def',
4: 'ghi',
5: 'jkl',
6: 'mno',
7: 'pqrs',
8: 'tuv',
9: 'wxyz'
}
var letterCombinations = function(digits) {
let ans = []
if(digits.length == 0) return ans
const solve = (index, result) => {
if(index == digits.length) ans.push(result)
else {
map[digits[index]].split('').forEach(word => solve(index + 1, result + word))
}
}
solve(0, '')
return ans
};
const map = {
'(':')',
'[':']',
'{':'}'
}
var isValid = function(s) {
let stack = []
s = s.split('')
while(s.length!=0) {
let temp = s.shift()
if(map[stack[stack.length-1]]==temp) stack.pop()
else stack.push(temp)
}
return stack.length == 0
};
var mergeTwoLists = function(list1, list2) {
const trans = node => {
let array = []
while(node) {
array.push(node.val)
node = node.next
}
return array
}
const list = [...trans(list1), ...trans(list2)].sort((a, b) => a - b)
let ans = new ListNode()
let p = ans
list.forEach(item => {
p.next = new ListNode(item)
p = p.next
})
return ans.next
};
var searchRange = function(nums, target) {
return [nums.indexOf(target), nums.lastIndexOf(target)]
};
var combinationSum = function(candidates, target) {
let ans = []
candidates.sort((a, b) => a - b)
const solve = (index, target, array) => {
if(target < 0) return
if(target == 0) return ans.push(array)
for(let i = index; i < candidates.length; i++) {
solve(i, target - candidates[i], [...array, candidates[i]])
}
}
solve(0, target, [])
return ans
};
var permute = function(nums) {
let ans = []
const solve = (cur, rest) => {
if(cur.length == nums.length) ans.push(cur)
rest.forEach(e => solve([...cur, e], rest.filter(num => num!=e)))
}
solve([], nums)
return ans
};
var maxSubArray = function(nums) {
if(nums.length == 1) return nums[0]
let ans = nums[0]
let dp = [nums[0]]
for(let i = 1; i < nums.length; i++) {
dp[i] = dp[i - 1] > 0? dp[i - 1] + nums[i] : nums[i]
ans = Math.max(ans, dp[i])
}
return ans
};
var merge = function(intervals) {
intervals.sort((a, b) => a[0] - b[0])
let ans = [intervals[0]]
for(let interval of intervals) {
if(ans.slice(-1)[0][1] >= interval[0]) {
ans.slice(-1)[0][1] = Math.max(ans.slice(-1)[0][1], interval[1])
} else {
ans.push(interval)
}
}
return ans
};
var uniquePaths = function(m, n) {
let dp = Array.from(Array(m), () => Array(n).fill(1))
for(let i = 1; i < m; i++)
for(let j = 1; j < n; j++)
dp[i][j] = dp[i-1][j] + dp[i][j-1]
return dp[m-1][n-1]
};
var climbStairs = function(n) {
let dp = []
dp.push(0, 1, 2)
for(let i = 3; i <= 45; i++)
dp.push(dp[i - 1] + dp[i - 2])
return dp[n]
};
var sortColors = function(nums) {
nums.sort()
};
var inorderTraversal = function(root, ans = []) {
if(!root) return ans
inorderTraversal(root.left, ans)
ans.push(root.val)
inorderTraversal(root.right, ans)
return ans
};
var isSymmetric = function(root) {
if(root == null) return true
const dfs = (p, q) => {
if(p == null && q == null) return true
if([p, q].includes(null)) return false
if(p.val != q.val) return false
return dfs(p.left, q.right) && dfs(p.right, q.left)
}
return dfs(root.left, root.right)
};
var maxDepth = function(root) {
return root? Math.max(maxDepth(root.left), maxDepth(root.right)) + 1 : 0
};
var singleNumber = function(nums) {
const count = nums.reduce((pre, cur)=> {
pre[cur]? pre[cur]++ : pre[cur] = 1
return pre
}, {})
return Object.entries(count).sort(([key1, value1], [key2, value2]) => value1 - value2)[0][0]
};
var majorityElement = function(nums) {
const count = nums.reduce((pre, cur)=> {
pre[cur]? pre[cur]++ : pre[cur] = 1
return pre
}, {})
return Object.entries(count).sort(([key1, value1], [key2, value2]) => value2 - value1)[0][0]
};
var reverseList = function(head) {
let [pre, cur] = [null, head]
while(cur) [cur.next, pre, cur] = [pre, cur, cur.next]
return pre
};
var moveZeroes = function(nums) {
for(let i = 0, l = nums.length; i < l; i++) {
if(nums[i] == 0) {
nums.splice(i, 1)
nums.push(0)
i--
l--
}
}
};
var findDuplicate = function(nums) {
const count = nums.reduce((pre, cur) => {
pre[cur]? pre[cur]++ : pre[cur] = 1
return pre
}, {})
return Object.entries(count).sort(([key1, value1], [key2, value2]) => value2 - value1)[0][0]
};
var findDisappearedNumbers = function(nums) {
let range = Array(nums.length).fill().map((_, index) => index + 1)
return range.filter(item => !nums.includes(item))
};
var hammingDistance = function(x, y) {
return (x^y).toString(2).split('').filter(i => i == '1').length
};
const judge = str => str.split('').reverse().join('') == str
var countSubstrings = function(s) {
let ans = 0
for(let i = 0; i < s.length; i++)
for(let j = i + 1; j < s.length + 1; j++)
if(judge(s.slice(i, j))) ans++
return ans
};
