2023-11-16-algo.md

一个等差数列是一个能表示成a, a+b, a+2b,..., a+nb (n=0,1,2,3,...)的数列。在这个问题中a是一个非负的整数，b是正整数。 现给出三个整数，分别表示等差数列的第一项a、最后一项和公差b，求该数列的和。

输入三个整数，之间用空格隔开。第1个数作为首项，第2个数作为末项，第3个数作为公差.

输出占一行，包含一个整数，为该等差数列的和。如果所给三个整数，不能构成等差数列，则返回-1。

 public static void main(String[] args) {
       Scanner scan = new Scanner(System.in);

       String str_0 = scan.nextLine();
        String[] line_list_0 = str_0.trim().split(" ");
        ArrayList<Integer> arr = new ArrayList<>();
        for (int i = 0; i < line_list_0.length; i++) {
            arr.add(Integer.parseInt(line_list_0[i]));
        }
        scan.close();
        int result = solution(arr);
        System.out.println(result);

    }

    public static int solution(ArrayList<Integer> arr) {
        int result = 0;
        if (arr.get(1) <= arr.get(0)) {
            //值无法等差
            return -1;
        }
        if ((arr.get(1) - arr.get(0)) % arr.get(2) != 0) {
            //头尾不能等差
            return -1;
        }
        for (int i = 0; i < (arr.get(1) - arr.get(0)) / arr.get(2) + 1; i++) {
            int val = arr.get(0) + i * arr.get(2);
            result += val;
        }

        return result;
    }

书是人类进步的阶梯。 小艺每周因为工作的原因会选择性的每天多读几页或者少读几页。 小艺想知道一本n页的书她会在周几读完。 第一行输入n(1<=n<=1000)； 第二行输入7个整数，分别表示周一~周日的读书页数p(0<=p<=1000)。（不考虑7个整数都为0的情况） 输出答案。（1-7）

  public static void main(String[] args) {
        String str_1 = "15 20 20 15 10 30 45";
        int n = 100;
        String[] line_list_1 = str_1.trim().split(" ");
        ArrayList<Integer> pages = new ArrayList<>();
        for (int i = 0; i < line_list_1.length; i++) {
            pages.add(Integer.parseInt(line_list_1[i]));
        }
        int result = solution(n, pages);
        System.out.println(result);

    }

    public static int solution(int n, ArrayList<Integer> pages) {
        int totalPages = 0;
        while (true) {
            for (int i = 0; i < 7; i++) {
                totalPages += pages.get(i);
                if (totalPages >= n) {
                    return  i + 1;
                }
            }
        }
    }

逆波兰记法中，操作符置于操作数的后面。例如表达“三加四”时，写作“3 4 +”，而不是“3 + 4”。如果有多个操作符，操作符置于第二个操作数的后面，所以常规中缀记法的“3 - 4 + 5”在逆波兰记法中写作“3 4 - 5 +”：先3减去4，再加上5。使用逆波兰记法的一个好处是不需要使用括号。例如中缀记法中“3 - 4 * 5”与“（3 - 4）*5”不相同，但后缀记法中前者写做“3 4 5 * -”，无歧义地表示“3 (4 5 *) -”；后者写做“3 4 - 5 *”。（测试用例仅做参考，我们会根据代码质量进行评分）

第一行输入一个整数 n，表示包含元素数量.(1<=n<=1000) 第二行输入n个元素。

波兰式和逆波兰式是一种数学表达式的表示方式，其中波兰式是将运算符写在操作数之前，而逆波兰式则是将运算符写在操作数之后。 例如，对于表达式 3 + 4 * 5：

波兰式：+ 3 * 4 5 逆波兰式：3 4 5 * + 波兰式的优势在于它可以简化计算的顺序，因为它不需要括号来确定优先级。但是，由于人类习惯于将运算符放在操作数之间，因此它不如逆波兰式易于理解。 波兰式（Polish notation）和逆波兰式（Reverse Polish notation）是数学表达式的两种表示方法。

150. 逆波兰表达式求值

根据 逆波兰表示法，求表达式的值。

有效的运算符包括 +, -, *, / 。 每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：

• 整数除法只保留整数部分。
• 给定逆波兰表达式总是有效的。 换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

输入: ["2", "1", "+", "3", "*"] 输出: 9 解释: 该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

1 + (5 - 2) * 3 1+((5-2)3) = 1+((52-)3) = 1+(52-3) = 152-3+

1,5,2,- 1,3,3,* 1,9,+ 10

给定一个只包含数字的字符串，用以表示一个 IP 地址，返回所有可能从 s 获得的 有效 IP 地址 。你可以按任何顺序返回答案。

有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "[email protected]" 是 无效 IP 地址。

示例 1：

输入：s = "25525511135" 输出：["255.255.11.135","255.255.111.35"] 示例 2：

输入：s = "0000" 输出：["0.0.0.0"] 示例 3：

输入：s = "1111" 输出：["1.1.1.1"] 示例 4：

输入：s = "010010" 输出：["0.10.0.10","0.100.1.0"] 示例 5：

输入：s = "101023" 输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]

提示：

0 <= s.length <= 3000 s 仅由数字组成

public static int solution( String arr) {
        String[] array = arr.split(" ");
        Stack<Integer> stack = new Stack<>();
        for (String c : array) {
            if (!"+-*/".contains(c)) {
                stack.push(Integer.parseInt(c));
                continue;
            }
            int b = 0;
            if (!stack.empty()) {
                b = stack.pop();
            }
            int a = 0;
            if (!stack.empty()) {
                a = stack.pop();
            }
            if ("+".equals(c)) {
                stack.push(a + b);
            } else if ("-".equals(c)) {
                stack.push(a - b);
            } else if ("*".equals(c)) {
                stack.push(a * b);
            } else if ("/".equals(c)) {
                stack.push(b == 0 ? 0 : a / b);
            }
        }
        if (stack.empty()) {
            return 0;
        }
        return stack.peek();
    }

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

示例 1：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3 输出：[1,2,2,3,5,6] 解释：需要合并 [1,2,3] 和 [2,5,6] 。 合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。 示例 2：

输入：nums1 = [1], m = 1, nums2 = [], n = 0 输出：[1] 解释：需要合并 [1] 和 [] 。 合并结果是 [1] 。 示例 3：

输入：nums1 = [0], m = 0, nums2 = [1], n = 1 输出：[1] 解释：需要合并的数组是 [] 和 [1] 。 合并结果是 [1] 。 注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

提示：

nums1.length == m + n nums2.length == n 0 <= m, n <= 200 1 <= m + n <= 200 -109 <= nums1[i], nums2[j] <= 109

进阶：你可以设计实现一个时间复杂度为 O(m + n) 的算法解决此问题吗？