java_5题

1、739. 每日温度
https://leetcode-cn.com/problems/daily-temperatures/
已知每日气温列表，求每日的气温多少天后会出现更高的气温。
例如：给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在 [30, 100] 范围内的整数。

    public int[] dailyTemperatures(int[] T) {
        int[] res = new int[T.length];
        for (int i = 0; i < T.length; i++) {
            for(int j = i+1; j < T.length; j++) {
                if(T[j] > T[i]) {
                    res[i] = j - i;
                    break;
                } else {
                    res[i] = 0;
                }
            }
        }
        return res;
    }

2、打印正三角、倒三角

    public static void printTriangle(int n) {
        for (int i = 1; i <= n; i++){
            for (int m = n; m > i; m--){
                System.out.print(" ");
            }
            for (int k = 0; k < 2*i-1; k++){
                if ( k == 2*i-2){
                    System.out.println("*");
                } else {
                    System.out.print("*");
                }
            }
        }
    }

    public static void printInvertedTriangle(int n) {
        for (int  i = n; i >= 1; i--) {
            for(int j = n; j > i; j--) {
                System.out.print(" ");
            }

            for (int k = 0; k < 2*i-1; k++) {
                if(k == 2*i-2) {
                    System.out.println("*");
                } else {
                    System.out.print("*");
                }
            }
        }
    }

参考：打印正三角形和倒三角形
https://www.jianshu.com/p/acc4b99e03a6

3、漂亮的帕斯卡三角数阵（在中国通常称作杨辉三角）
二项式定理的通俗解释
http://www.360doc.com/content/19/0408/20/55209520_827294386.shtml

java代码打印杨辉三角

import java.util.Scanner;
public class DemoTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入N的值：");
        int num = sc.nextInt();
        int[][] arr = new int[num][num];
        sortMethod(arr);
    }
    private static void sortMethod(int[][] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int n = 0; n <= i; n++) {
                arr[i][0] = 1;
                arr[n][i] = 1;
                if (i >= 2 && n >= 1 && n < i) {
                    arr[i][n] = arr[i - 1][n - 1] + arr[i - 1][n];
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            for(int j = i+1; j < arr.length; j++) {
                System.out.print("  ");
            }
            for (int n = 0; n <= i; n++) {
                if(n == i) {
                    System.out.println(arr[i][n]);
                } else {
                    System.out.print(arr[i][n] + "   ");
                }
            }
        }
    }
}

参考资料：Java中的杨慧三角编写
https://blog.csdn.net/liupf1203/article/details/51297469
组合数学中杨辉三角与二项式定理以及代码实现
https://blog.csdn.net/amazingee/article/details/105009265
神奇数阵帕斯卡三角形
https://juzihuang.com/doc/1132.html

贾宪（杨辉 帕斯卡 巴斯卡）三角形（经典算法Java的实现)
https://blog.csdn.net/wqq530sc/article/details/83569827

import java.awt.*;
import javax.swing.*;
public class Pascal extends JFrame {
    public Pascal()
    {
        setBackground(Color.white);
        setTitle("巴斯卡三角形");
        setSize(520, 350);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        show();
    }
    private long combi(int n, int r)
    {
        int i;
        long p = 1;
        for(i = 1; i <= r; i++)
            p = p * (n-i+1) / i;
        return p;
    }
    public void paint(Graphics g)
    {
        final int N = 12;
        int n, r, t;
        for(n = 0; n <= N; n++)
        {
            for(r = 0; r <= n; r++)
                g.drawString(" " + combi(n, r),
                        (N-n)*20 + r * 40, n * 20 + 50);
        }
    }
    public static void main(String args[])
    {
        Pascal frm = new Pascal();
    }
}

4、用Java判断包含括号 { [ ( ) ] } 的表达式是否合法

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

public class ParentMatchTest {
    public static void main(String[] args) {
        //System.out.println("Hello World!");
        boolean ret;
        ret  = parenMatch("{}(([{}])){}{}");
        System.out.println("ret = " + ret);
        ret  = parenMatch("{[(");
        System.out.println("ret = " + ret);
        ret  = parenMatch(")]}");
        System.out.println("ret = " + ret);

        ret  = parenMatch("(([{]}))");
        System.out.println("ret = " + ret);
    }

    private static boolean parenMatch(String expression) {
        //将括号对应关系放到map里，方便后面根据开始符号取对应的结束符号
        Map<Character, Character> map = new HashMap<>();
        map.put('(', ')');
        map.put('[', ']');
        map.put('{', '}');

        Stack<Character> stack = new Stack();
        char[] exp = expression.toCharArray();
        for (int i = 0; i < exp.length; i++) {
            if(exp[i] == '(' || exp[i] == '[' || exp[i] == '{' ) {
                stack.push(exp[i]);
            } else if (exp[i] == ')' || exp[i] == ']' || exp[i] == '}' ) {
                if(stack.size() <= 0) {
                    return false;
                }
                Character c = stack.pop();
                if(exp[i] != map.get(c)) {
                    return false;
                }
            }
        }
        if(stack.isEmpty()) {
            return true;
        } else {
            return false;
        }
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

public class ParentMatchTest {
    public static void main(String[] args) {
        //System.out.println("Hello World!");
        boolean ret;
        ret  = parenMatch("{}(([{}])){}{}");
        System.out.println("ret = " + ret);
        ret  = parenMatch("{[(");
        System.out.println("ret = " + ret);
        ret  = parenMatch(")]}");
        System.out.println("ret = " + ret);

        ret  = parenMatch("(([{]}))");
        System.out.println("ret = " + ret);
    }

    private static boolean parenMatch(String expression) {
        //将括号对应关系放到map里，方便后面根据开始符号取对应的结束符号
        Map<String, String> map = new HashMap<>();
        map.put("(", ")");
        map.put("[", "]");
        map.put("{", "}");

        Stack<Character> stack = new Stack();
        char[] exp = expression.toCharArray();
        for (int i = 0; i < exp.length; i++) {
            if(exp[i] == '(' || exp[i] == '[' || exp[i] == '{' ) {
                stack.push(exp[i]);
            } else if (exp[i] == ')' || exp[i] == ']' || exp[i] == '}' ) {
                if(stack.size() <= 0) {
                    return false;
                }
                String c = String.valueOf(stack.pop());
                if(exp[i] != map.get(c).toCharArray()[0]) {
                    return false;
                }
            }
        }
        if(stack.isEmpty()) {
            return true;
        } else {
            return false;
        }
    }
}

参考：https://blog.csdn.net/u011998957/article/details/88086877

4.2 给定字符串input,例如：“9,(1,(2,3),((5),4))”，输出字符串中所有数字num与其对应层数level的乘积之和。例如:90+11+22+32+53+42=34

public class SimpleTest{
    public static void main(String[] args) {
        String inputs = "9,(1,(2,3),((5),4))";
        int ret = Solution.levelSum(inputs);
        System.out.println("ret = " + ret);
    }

    private static class Solution {
        public static int levelSum(String input) {
            if(input == null || input.length() == 0) {
                return 0;
            }

            int sum = 0;
            int cnt = 0;
            for (int i = 0; i < input.length(); i++) {
                char c = input.charAt(i);
                switch (c) {
                    case '(' :
                        cnt++;
                        break;
                    case ')' :
                        cnt--;
                        break;
                    case ',' :
                        break;
                    default:
                        sum += (c - '0')*cnt;
                }
            }
            return sum;
        }
    }
}

仔细看，代码有bug对于多位数的情况处理失败，需要修改，如下：

public class SimpleTest{
    public static void main(String[] args) {
        String inputs;
        int ret;
        inputs = "9,(1,(2,3),((5),4))";
        ret = Solution.levelSum(inputs);
        System.out.println("ret = " + ret);

        inputs = "9,(10,(2,3),((5),4))";
        ret = Solution.levelSum(inputs);
        System.out.println("ret = " + ret);
    }

    private static class Solution {
        public static int levelSum(String input) {
            if (input == null || input.length() == 0) {
                return 0;
            }
            String[] nums = input.split("[^0-9]+");
            int sum = 0;
            int level = 0;
            int index = 0;
            for(int i = 0; i < input.length(); i++) {
                if(input.charAt(i) == '(') level++;
                else if (input.charAt(i) == ')') level--;
                else if (input.charAt(i) == ',') index++;
                else {
                    sum += Integer.valueOf(nums[index]) * level;
                    i += (nums[index].length() - 1);
                }
            }
            System.out.println(sum);
            return sum;
        }
    }
}

4.2 对数组input[]按从小到大排序，问排序后有几个元素的位置发生变化。

import java.util.Arrays;

public class SimpleTest2 {
    public static void main(String[] args) {
        int[] inputs = {1,1,1,2,4,3};
        int ret = Solution.labelCheker(inputs);
        System.out.println("ret = " + ret);
    }
    private static class Solution {
        public static int labelCheker(int[] labels) {
            int[] copy = labels.clone();
            Arrays.sort(copy);
            int ret = 0;
            for (int i = 0; i < labels.length; i++) {
                if( copy[i] != labels[i]) {
                    ret++;
                }
            }
            return ret;
        }
    }
}

5、光传播
在n*m的二维矩阵（左上角为[0,0]）中，设置若干光源，并以[光源所在行，光源所在列，光源照度]的形式记录与二维数组light中。（1）假设光照度强度light随离光源的距离光源递减，每1单元格减少1照度，直至照度减小为1（即光照覆盖区域边缘照度为1）
（2）假设同一格被多个光源覆盖时，检测结果不叠加，仅保留较大的照度值。

在光源开启且传播情况稳定后，请检测每格光照度并返回其总和。注意：
（1）除光源外所有格的初始值为0照度；
（2）不考虑光反射。
示例1：
输入： n =5, m = 6, light = {{3,4,3},{1,1,4}}
输出：63

public class LightCount {
    public static void main(String[] args) {
        int n = 5;
        int m = 6;
        int light[][] = {{3,4,3},{1,1,4}};
        int ret = spreadLight(n,m,light);
        System.out.println("ret = " + ret);
    }

    public static int spreadLight(int n, int m, int[][] light) {
        int[][] map = new int[n][m];
        for (int[] ints : light) {
            int row = ints[0];
            int col = ints[1];
            int val = ints[2];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    int cnt = Math.max(Math.abs(row - i), Math.abs(col - j));
                    map[i][j] = Math.max(map[i][j], val - cnt);
                }
            }
        }
        int res = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                res += map[i][j];
            }
        }
        return res;
    }
}

参考：https://zh.wikipedia.org/wiki/%E7%85%A7%E5%BA%A6 --20200424