在力扣刷题的小记录

import org.junit.Test;

import java.util.Arrays;

public class ThinKingInJava{


    @Test
    public static void main(String[] args) {
        int a = 1585;
        int b = 1584;
        System.out.println(a/b);
        System.out.println("更新数据成功率为："+Double.valueOf(b)/Double.valueOf(a)*100.0+"%");
        //正数反转
        //reverse(1231231231);

        // 二叉树
        //binaryTree();

        //回文数
        //isPalindrome(121);

        //移除元素
        int[] nums = new int[]{3,2,2,3,2,4,5};
        int val = 3;
        //removeElement(nums,val);

        numDecodings("土");
    }

    /**
     * 179.最大数
     *
     * 给定一组非负整数 nums，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。
     * 注意：输出结果可能非常大，所以你需要返回一个字符串而不是整数。
     *  提示：
     *     1 <= nums.length <= 100
     *     0 <= nums[i] <= 109
     *  参考数据 ：
     *  int[] nums = new int[]{3,30,34,5,9};
     *  String maxNum = largestNumber(nums);
     *  System.out.println(maxNum);
     *  返回结果"9534330"
     *
     *  最简洁写法参考答案
     * @param nums
     * @return
     */
    public String largestNumber(int[] nums){
        return Arrays.stream(nums)
                .mapToObj(Integer::toString)
                .sorted((s1, s2) -> (s2 + s1).compareTo(s1 + s2))
                .reduce("", (s1, s2) -> s1.equals("0") ? s2 : s1 + s2);
    }

//----------------------------------------------------------------------------------------------------------------------

    /**
     * 783. 二叉搜索树节点最小距离
     *
     * 给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。
     * 参考数据：
     *      binaryTree();
     */
    static int min = Integer.MAX_VALUE;
    static int preVal = -1;
    public static void binaryTree(){
        TreeNode root1 = new TreeNode(2,new TreeNode(1),new TreeNode(3));
        TreeNode root = new TreeNode(4,root1,new TreeNode(6));
        minDiffInBST(root);
        System.out.println(min);
    }
    public static void minDiffInBST(TreeNode root) {
        if(root != null){
            // 先遍历左子树，然后根节点，最后右子树
            minDiffInBST(root.left);// 左子树节点
            if(preVal == -1){
                preVal = root.val;
            }else{
                min = Math.min(root.val-preVal,min);// 根据二叉树 preVal永远为最小值
                preVal = root.val;
            }
            minDiffInBST(root.right);// 右子树节点
        }
    }
    /**
     * 二叉树节点的定义
     * Definition(定义) for a binary(二进制) tree(树) node(节点).
     */
    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

//----------------------------------------------------------------------------------------------------------------------

    /**
     * 7. 整数反转
     * 给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
     *
     * 如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。
     * 假设环境不允许存储 64 位整数（有符号或无符号）。
     *
     * @param x
     * @return
     */
    public static int reverse(int x) {
        long returnNUm = 0L;
        if(x==0){
            return 0;
        }
        while(x!=0){
            returnNUm = returnNUm*10+x%10;
            x = x/10;
        }
        return (returnNUm>Integer.MAX_VALUE || returnNUm<Integer.MIN_VALUE)?0:(int)returnNUm;
    }

//----------------------------------------------------------------------------------------------------------------------

    /**
     * 9. 回文数
     *
     *  给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
     *  回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。
     * @param x
     * @return
     */
    public static boolean isPalindrome(int x) {
        StringBuilder b = new StringBuilder(String.valueOf(x));
        return String.valueOf(x).equals(b.reverse().toString());
    }

//----------------------------------------------------------------------------------------------------------------------

    /**
     * 13. 罗马数字转整数
     *
     * 罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
     *
     * 字符          数值
     * I             1
     * V             5
     * X             10
     * L             50
     * C             100
     * D             500
     * M             1000
     *
     * 例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。
     *
     * 通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
     *
     *     I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
     *     X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
     *     C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
     *
     * 给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。
     *
     * 参考数据 s="MCMXCIV";
     */
    public static int romanToInt(String s){
        int sLength = s.length();
        int roman_int = 0;
        for(int i=0;i<sLength;i++){
            switch(s.charAt(i)){
                case 'I' : roman_int = roman_int + 1;break;
                case 'V' : roman_int = roman_int + 5;break;
                case 'X' : roman_int = roman_int + 10;break;
                case 'L' : roman_int = roman_int + 50;break;
                case 'C' : roman_int = roman_int + 100;break;
                case 'D' : roman_int = roman_int + 500;break;
                case 'M' : roman_int = roman_int + 1000;break;
            }
            if(i!=0){
                if((s.charAt(i)=='V' || s.charAt(i)=='X') && s.charAt(i-1)=='I'){
                    roman_int = roman_int -1*2;
                }
                if((s.charAt(i)=='L' || s.charAt(i)=='C') && s.charAt(i-1)=='X'){
                    roman_int = roman_int -10*2;
                }
                if((s.charAt(i)=='M' || s.charAt(i)=='D') && s.charAt(i-1)=='C'){
                    roman_int = roman_int -100*2;
                }
            }
        }
        return roman_int;
    }

//----------------------------------------------------------------------------------------------------------------------

    /**
     *  27. 移除元素
     *
     *  给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
     *
     * 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
     *
     * 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
     *
     * 说明:
     * 为什么返回数值是整数，但输出的答案是数组呢?
     * 请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
     * 你可以想象内部操作如下:
     *
     * // nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
     * int len = removeElement(nums, val);
     *
     * // 在函数里修改输入数组对于调用者是可见的。
     * // 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
     * for (int i = 0; i < len; i++) {
     *     print(nums[i]);
     * }
     *  nums = [3,2,2,3]
     *  val = 3
     * @param nums
     * @param val
     * @return
     */
    public static int removeElement(int[] nums, int val) {
        // 该方法受题目限制
        nums = Arrays.stream(nums).filter(a -> a!=val).toArray();
        Arrays.stream(nums).forEach(s -> System.out.println(s));
        // 答案
        int i = 0;
        for(int num:nums){
            if(num!=val){
                nums[i++] = num;
            }
        }
        return i;
    }

//----------------------------------------------------------------------------------------------------------------------

    /**
     * 91. 解码方法
     * 一条包含字母 A-Z 的消息通过以下映射进行了 编码 ：
     *
     * 'A' -> 1
     * 'B' -> 2
     * ...
     * 'Z' -> 26
     *
     * 要 解码 已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，"11106" 可以映射为：
     *
     *     "AAJF" ，将消息分组为 (1 1 10 6)
     *     "KJF" ，将消息分组为 (11 10 6)
     *
     * 注意，消息不能分组为  (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。
     *
     * 给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。
     *
     * 题目数据保证答案肯定是一个 32 位 的整数。
     * @param s
     * @return
     */
    public static int numDecodings(String s){

        Integer[] integers  = new Integer[]{};
        for(int i=0;i<s.length();i++){
            int a = Integer.valueOf(s.charAt(i));
        }
        return 1;
    }



}