<!--
* @Description:
* @Version: 1.0
* @Date: 2021-10-27 15:43:26
-->
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
<style>
</style>
</head>
<body>
</body>
<script>
// 给你一个有序数组 nums ,请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
// 不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
// 输入：nums = [1,1,2]
// 输出：2, nums = [1,2]
// 解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
/**
* @param {number[]} nums
* @return {number}
*/
// var removeDuplicates = function(nums) {
// };
var removeDuplicates = function (nums) {
const list = Array.from(new Set(nums))
nums.splice(list.length, nums.length - list.length)
list.forEach((el, i) => {
nums[i] = el
})
return nums.length
};
var nums = [1, 1, 2]
// console.log(removeDuplicates(nums))
// 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
// 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
var removeElement = function (nums, val) {
for (let i = 0; i < nums.length; i++) {
if (nums[i] == val) {
nums.splice(i, 1)
i--
}
}
return nums.length
};
nums = [3, 2, 2, 3], val = 3
// console.log(removeElement(nums, val))
// 输入：haystack = "hello", needle = "ll"
// 输出：2
var strStr = function (haystack, needle) {
return haystack.indexOf(needle)
};
haystack = "", needle = ""
// console.log(strStr(haystack, needle))
// 输入: nums = [1,3,5,6], target = 5
// 输出: 2
nums = [-1, 3, 5, 6], target = 0
var searchInsert = function (nums, target) {
let pos = nums.indexOf(target)
var res = null
if (pos > -1) {
res = pos
} else {
for (let i = 0; i < nums.length; i++) {
if (nums[i] > target) {
res = i
break
}
}
res = res == 0 ? 0 : (res || nums.length)
}
return res
};
// console.log(searchInsert(nums, target))
// 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
nums = [-2]
var maxSubArray = function (nums) {
let curSum = nums[0];
let maxSum = nums[0];
for (let i = 1; i < nums.length; i++) {
curSum = Math.max(nums[i], nums[i] + curSum);
maxSum = Math.max(curSum, maxSum);
}
return maxSum;
};
// console.log(maxSubArray(nums))
// 给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
// 最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
// 你可以假设除了整数 0 之外，这个整数不会以零开头。
digits = [5, 6]
var plusOne = function () {
let num = digits.length - 1
if (num == 0 && digits[num] == 9) return [1, 0]
digits[num] = digits[num] + 1
for (let i = num; i > -1; i--) {
if (digits[i] > 9) {
digits[i] = 0
if (digits[i - 1]) {
digits[i - 1] = digits[i - 1] + 1
} else {
digits.unshift(1)
}
}
}
return digits
}
// console.log(plusOne(digits))
// 给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中最后一个单词的长度。
// 单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
// 示例 1：
// 输入：s = "Hello World"
// 输出：5
var lengthOfLastWord = function (s) {
let arr = s.trim().split(' ')
let res = arr[arr.length - 1].length
return res
};
s = "luffy is still joyboy"
// console.log(lengthOfLastWord(s))
// 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
// 有效字符串需满足：
// 左括号必须用相同类型的右括号闭合。
// 左括号必须以正确的顺序闭合。
// 输入： s = "()"
// 输出： true
var isValid = function (s) {
const stack = [],
map = {
"(": ")",
"{": "}",
"[": "]"
};
for (const x of s) {
if (x in map) {
stack.push(x);
continue;
};
if (map[stack.pop()] !== x) return false;
}
return !stack.length;
};
s = "()"
// console.log(isValid(s))
// 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
// 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
// 注意：给定 n 是一个正整数。
var climbStairs = function (n) {
let res
if (n < 3) {
return n
} else {
// 递归超时
// res = climbStairs(n-1)+climbStairs(n-2)
const arr = [];
arr[1] = 1;
arr[2] = 2;
for (let i = 3; i <= n; i++) {
arr[i] = arr[i - 1] + arr[i - 2];
console.log("=================>", arr[i])
}
return arr[n];
}
// return res
};
// console.log(climbStairs(5))
// 给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
var findMedianSortedArrays = function (nums1, nums2) {
let res
let newArr = nums1.concat(nums2).sort((a, b) => {
return a - b
})
let len = newArr.length
if (len % 2 == 0) {
res = (newArr[len / 2] + newArr[len / 2 - 1]) / 2
} else {
res = newArr[(len - 1) / 2]
}
return res.toFixed(4)
};
nums1 = [0, 0], nums2 = [0, 0]
// console.log(findMedianSortedArrays(nums1,nums2))
// 给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
// 请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
// 注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
var merge = function (nums1, m, nums2, n) {
let pos = nums1.indexOf(0, m)
for (let i = 0; i < n; i++) {
nums1[pos + i] = nums2[i]
}
nums1.sort((a, b) => {
return a - b
})
return nums1
};
// nums1 = [1, 2, 3, 0, 0, 0], m = 3, nums2 = [2, 5, 6], n = 3
// nums1 = [1], m = 1, nums2 = [], n = 0
// nums1 = [0], m = 0, nums2 = [1], n = 1
nums1 = [0, 0, 0, 0, 0], m = 0, nums2 = [1, 2, 3, 4, 5], n = 5
// console.log(merge(nums1, m, nums2, n))
// 给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。
// 如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
var isSameTree = function (p, q) {
if (!p && !q) return true;
if (p && q) {
return p.val !== q.val ? false : isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
}
return false;
}
p = [1, 2, 3], q = [1, 2, 3]
// console.log(isSameTree(p,q))
</script>
</html>