算法题1:计算日期到天数转换:

我们假设用例输入的是2022 1 1，那么我们对应的天数就是1天，我们就不应该在输出1月份的所有月数

public class Main {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int year=scanner.nextInt();
        int month=scanner.nextInt();
        int day=scanner.nextInt();
//我们把1到12月份数字全部进行用数组保存起来
   int[] array=new int[]{31,29,31,30,31,30,31,31,30,31,30,31};
   int sum=0;
   for(int i=1;i<month;i++){
//对于闰年年份我们要进行特殊处理
        if(i==2){
           if((year%4==0&&year%100!=0)||(year%400==0)){
                sum=sum+array[i-1];
                continue;
            }else{
               sum=sum+28;
                continue;
            }
        }
        sum=sum+array[i-1];
   }
//最后我们要特殊进行处理天数
   sum=sum+day;
   System.out.println(sum);
    }
}      

算法题2:幸运的袋子幸运的袋子_牛客题霸_牛客网

题目描述:我们假设一个袋子里面有N个球，每一个球上面都有一个号码(拥有相同号码的球是没有区别的)，如果说一个袋子是幸运的，那么当且仅当所有的球的号码的和大于所有球的号码的积，比如说袋子里面的球的号码是{1，1，2，3}，那么这个袋子就是幸运的，因为1+1+2+3>1*1*2*3

你可以适当的从袋子里面移除一些球，可以移除0个，但是不要移除完，我们要使移除完之后的袋子是幸运的，请你现在通过编程计算一下你可以获得多少种不同的幸运的袋子

思路:

1)我们先将袋子中的球来进行排序

2)当我们的一个号码和前面的号码无法组成一个幸运的袋子，那么就直接break，因为后面的号码肯定比前面的号码大，也无法构成幸运的袋子

3)当我们返回上层的递归的时候，需要进行回溯，需要继续进行判断前面的号码和当前位置后面的号码是否可以构成幸运的袋子

特殊情况:a[i]==1，1和任何数的和都是大于1和任何数的积

注意题目中已经说了相同号码的球是没有区别的

import java.util.*;
public class Main {
    public static void main(String[] args) {
       Scanner scanner=new Scanner(System.in);
       while(scanner.hasNextInt()){
       int n=scanner.nextInt();
       int[] array=new int[n];
       for(int i=0;i<n;i++){
        array[i]=scanner.nextInt();
       }
        Arrays.sort(array);
    System.out.println(Count(array,n,0,0,1));
       }
    }
public static int Count(int[] array,int len,int pos,int sum,int mult){
          int count=0;
          for(int i=pos;i<len;i++){
                sum=sum+array[i];
                mult=mult*array[i];
                if(sum>mult){
                   count=count+1+Count(array,len,i+1,sum,mult);
                }else if(array[i]==1){
                        count+=Count(array,len,i+1,sum,mult);
                }else{
                        break;
                }
//向上进行回溯的时候sum进行减减操作,mult进行除以这个array[i]
                sum=sum-array[i];
                mult=mult/array[i];
                while(i<len-1&&array[i]==array[i+1]){
                        i++;
                }
          }
          return count;
  }
}

算法题三:无重复字符串的最长子串

思路:

1)我们使用一个数据结构叫做HashSet来进行保存遍历到的每一个字符串

2)我们进行定义两个指针，left和right，我们在让right向后移动的过程中，把right遍历到的每一个字符串放到HashSet集合里面，如果说我们的right下标在进行向后++的过程中发现，此时right的下表的元素里面在HashSet中已经存在，说明此时一定在left到right的这一下标范围内遇到了重复的字符

3)如果说我们最终遇到了重复的字符，那么我们right下标的字符就没有办法放到hashSet集合里面了，此时我们就应该left向后进行移动，删除对应的left的元素，直到把把对应的hashSet中的集合元素中包含的right下标的元素进行删除即可

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if(s==null||s.equals("")){
            return 0;
        }
     char[] array=s.toCharArray();
     int left=0;
     int right=0;
     int length=0;
     int MaxLength=0;
     HashSet<Character> result=new HashSet<>();
     while(right<array.length){
         if(right<array.length&&!result.contains(array[right])){
             result.add(array[right]);
             right++;
             length++;
             if(length>MaxLength){
                 MaxLength=length;
             }
         }
         if(right<array.length&&result.contains(array[right])){
             while(left<array.length&&result.contains(array[right])){
                 result.remove(array[left]);
                 left++;
                 length--;
             }
             result.add(array[right]);
             right++;
             length++;
         }
     }
     return MaxLength;

    }
}

算法题4:寻找两个升序数组的中位数

思路:我们可以先合并两个有序数组，然后直接就可以找出中位数

class Solution {
//1.我们先写两个函数进行合并两个有序数组
    public int[] mergeSort(int[] arr1,int[] arr2){
        int s1=0;
        int e1=arr1.length-1;
        int s2=0;
        int e2=arr2.length-1;
        int array[]=new int[arr1.length+arr2.length];
        int k=0;
        while(s1<=e1&&s2<=e2){
            if(arr1[s1]<=arr2[s2]){
                array[k]=arr1[s1];
                k++;
                s1++;
            }else{
                array[k]=arr2[s2];
                s2++;
                k++;
            }
        }
        while(s1<=e1){
            array[k++]=arr1[s1++];
        }
        while(s2<=e2){
            array[k++]=arr2[s2++];
        }
        return array;
    }
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
    int[] array=mergeSort(nums1,nums2);
//2.进行合并两个有序数组之后进行寻找中位数并进行返回
        if(array.length%2==1){
            return array[array.length/2];
        }else{
            return (array[array.length/2]+array[(array.length/2)-1])/2.0;
        }


    }
}