计算时间

//计算当前时间是当年的第几天

function dayOfYear(dateStr) {
    // 解析日期字符串
    const date = new Date(dateStr);
    // 验证日期有效性
    if (isNaN(date.getTime())) {
        throw new Error('Invalid date format. Please use "YYYY-M-D" format.');
    }
    // 获取当年第一天和当前日期
    const startOfYear = new Date(date.getFullYear(), 0, 1);
    console.log(startOfYear);
    // 计算天数差（毫秒转换为天）
    const diffInMs = date - startOfYear;
    const dayOfYear = Math.floor(diffInMs / (1000 * 60 * 60 * 24)) + 1;
    return dayOfYear;
}
console.log(dayOfYear('2022-2-05'));

//计算时间是当年的第几天
function time(str) {
    const data = new Date(str)
    console.log(data);
    if (isNaN(data.getTime())) {
        throw new Error('时间格式错误')
    }
    let timer = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    let getFullYear = data.getFullYear()
    let getMonth = data.getMonth() + 1
    let getDate = data.getDate()
    console.log(getFullYear, getMonth, getDate);

    if (getFullYear % 400 === 0 || (getFullYear % 4 === 0 && getFullYear % 100 !== 0)) {
        timer[2] = 29
    }
    let sum = getDate
    for (let i = 0; i < getMonth; i++) {
        sum += timer[i]
    }
    return sum
}
console.log(time('2022-12-05'));

编写一个函数，不仅能找出连续子数组的最大和，还能返回这个子数组本身。
function maxSubarray(arr){
    if(arr.length===0) return {sum:0,sarr:[]}


    let maxSum=arr[0]
    let currentSum=arr[0]
    let start=0
    let end=0
    let tempStart=0
    
    for(let i=1;i<arr.length;i++){
        if(arr[i]>currentSum+arr[i]){
            currentSum=arr[i]
            tempStart=i
        }else{
            currentSum+=arr[i]
        }
        if(currentSum>maxSum){
            maxSum=currentSum
            start=tempStart
            end=i
        }
    }
    return {sum:maxSum,sarr:arr.slice(start,end+1)}
}
console.log(maxSubarray([-2, 1, -3, 4, -1, 2, 1, -5, 4]));

给定一个未排序的整数数组 `nums` ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度

**示例 1：**
输入： nums = [100,4,200,1,3,2]
输出： 4
解释： 最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。

var longestConsecutive = function(nums) {
const ss=new Set(nums)
let ans=0
for(const s of ss){
    if(ss.has(s-1)){
        continue
    }
    let y=s+1;
    while(ss.has(y)){
        y++;
    }
    ans=Math.max(ans,y-s)
}
return ans
};

最长递增子序列
给你一个整数数组 nums ，找到其中最长严格递增子序列的长度
示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4

var lengthOfLIS = function(nums) {
    const dp=new Array(nums.length).fill(1)
    let maxlength=1
    for(let i=1;i<nums.length;i++){
        for(let j=0;j<i;j++){
            if(nums[i]>nums[j]){
                dp[i]=Math.max(dp[j]+1,dp[i])
            }
        }maxlength=Math.max(maxlength,dp[i])
    }
    return maxlength
};

给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。

完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。
示例 1：

输入：n = 12
输出：3 
解释：12 = 4 + 4 + 4

var numSquares = function(n) {
    const f=new Array(n+1).fill(0)
    for(let i=1;i<=n;i++){
        let minn=Number.MAX_VALUE;
        for(let j=1;j*j<=i;j++){
            minn=Math.min(minn,f[i-j*j])
        }
        f[i]=minn+1
    }
    return f[n]
};

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
示例 1：

输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]

var generateParenthesis = function(n) {
    const ans=[]
    const path=Array(n*2)
    function dfs(left,right){
        if(right ===n){
            ans.push(path.join(''))
        }
        if(left<n){
            path[left+right]='('
            dfs(left+1,right)
        }
        if(right<left){
            path[left+right]=')'
            dfs(left,right+1)
        }
       
    }
     dfs(0,0)
        return ans
};