leetcode-simple-共25题-02

26. 消失的数字

package com.lxh.simple;
/* 已通过 2021.10.12 时间5ms 击败33.41% 内存 38.9M 击败28.85%
*
*
*
* */
import java.util.Arrays;

public class MissingNumber0268 {
    public int missingNumber(int[] nums) {
        Arrays.sort(nums);
        int temp = 0;
        int i;
        for (i = 0; i < nums.length; i++) {
            if (nums[i] == i){}
            else {
                temp = i;
                break;
            }
        }
        return temp = i == nums.length ? i : temp;
    }
}

27. 排列硬币

package com.lxh.simple;
/* 已通过 2021.10.12 时间1ms 击败100% 内存35.8M 击败7.65%
* 本题自我感觉重点在于 对基本数据类型取值范围的掌握
* 
* 也可用折半查找解决
* */

public class ArrangingCoins0441 {
    public int arrangeCoins(int n) {
        long m = n;
        int temp = (int)Math.sqrt(2 * m);
        temp = (long)temp * (temp+1) / 2 <= n ? temp : temp - 1;
        return temp;
    }

    public static void main(String[] args) {
        ArrangingCoins0441 ac0441 = new ArrangingCoins0441();
        System.out.println(ac0441.arrangeCoins(1804289383));
    }
}

28. 3的幂

package com.lxh.simple;
/* 已通过 2021.10.13 时间8ms 击败100% 内存38.4MB 击败5.38%
* 递归调用
*
* */

public class PowerThree0326 {
    public boolean isPowerOfThree(int n) {
        if (n < 1)
            return false;
        if (n == 1)
            return true;
        return Recursion(n);
    }

    int flag = 1;
    private boolean Recursion(int n) {
        if (n == 1) {
            flag = 1;
        } else if(n % 3 == 0){
            flag = 1;
            n = n / 3;
            Recursion(n);
        } else
            flag = 0;
        return flag == 1;
    }

    public static void main(String[] args) {
        PowerThree0326 pt0231 = new PowerThree0326();
        System.out.println(pt0231.isPowerOfThree(45));
    }
}

29. 4的幂

package com.lxh.simple;
/* 已通过 2021.10.13 时间1ms 击败100% 内存35.5MB 击败31.77%
*
*
* */

public class PowerFour0342 {
    public boolean isPowerOfFour(int n) {
        while(n != 0 && n % 4 == 0) {
            n /= 4;
        }
        if(n == 1)
            return true;
        return false;
    }
}

30. 合并两个有序数组

package com.lxh.simple;
/* 已通过
*
*
* */

import java.util.Arrays;

public class MergeSortedArray0088 {
    public void merge(int[] nums1, int m, int[] nums2, int n) {

/*        if (n == 0) {
            System.out.println(Arrays.toString(nums1));
        }*/
/*        if (m == 0) {
            nums1 = nums2;
            System.out.println(Arrays.toString(nums1));
        }*/
/*
        StringBuilder result = new StringBuilder();

        for (int i = 0, j = 0; i < m;) {
            if (nums1[i] <= nums2[j]) {
                result.append(nums1[i]);
                i++;
            }
            else {
                result.append(nums2[j]);
                j++;
            }
            int temp = i;
            while (i == m - n && j < n) {
                result.append(nums2[j]);
                j++;
                temp++;
            }
            while (j == n && temp + 1 < m) {
                result.append(nums1[i]);
                i++;
            }
        }
        for (int k = 0; k < result.length(); k++) {
            nums1[k] = result.charAt(k);
        }
        System.out.println(Arrays.toString(nums1));*/

        for (int i = m, j=0; i < m+n; i++) {
            nums1[i] = nums2[j++];
        }
        Arrays.sort(nums1);
        System.out.println(Arrays.toString(nums1));
    }

    public static void main(String[] args) {
        MergeSortedArray0088 msa0088 = new MergeSortedArray0088();
        int[] nums1 = {0,0,0};
        int[] nums2 = {1,2,3};
        int m = 0;
        int n = 3;
        msa0088.merge(nums1, m, nums2, n);
    }
}

31. 反转字符串

package com.lxh.simple;
/* 已通过 2021.10.13 时间0ms 击败100% 内存45.1M 击败37.65%
* 一个简单的转换
*
*
* */
public class ReverseString0344 {
    public void reverseString(char[] s) {
        int i = 0;
        int j = s.length - 1;
        while(i <= j) {
            char temp = s[i];
            s[i] = s[j];
            s[j] = temp;
            i++;
            j--;
        }
        for (char c : s)
            System.out.print(c + " ");
    }

    public static void main(String[] args) {
        ReverseString0344 rs0344 = new ReverseString0344();
        char[] s = {'h','e','l','l','o','o'};
        rs0344.reverseString(s);
    }
}

32. 两个数组的交集

package com.lxh.simple;
/* 已通过 2021.10.13 时间2ms 击败91.11% 内存38.6MB 击败55.41%
* 本题 自己用了HashSet()方法 HashSet方法中关键字唯一 不会出现重复的
* 同时掌握由HashSet()转换为数组的过程 从而能应对各种情况。
*
* Ps: Arrays.copyOfRange(int[ ] original,int from,int to)
* 将一个原始的数组original，从下标from开始复制，复制到上标to，生成一个新的数组。
* 注意这里包括下标from，不包括上标to.
* 效率和clone基本一致，都是native method，比利用循环复制数组效率要高得多。
*

注意这里包括下标from，不包括上标to。
* */
import java.util.*;

public class IntersectionTwoArrays0349 {
    public int[] intersection(int[] nums1, int[] nums2) {
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        Set<Integer> result = new HashSet<>();

        int i = 0;
        int j = 0;
        int length = nums1.length <= nums2.length ? nums1.length : nums2.length;
        while(i < nums1.length && j < nums2.length) {
            if (nums1[i] == nums2[j]) {
                result.add(nums1[i]);
                i++;
                j++;
            } else if (nums1[i] < nums2[j])
                i++;
            else
                j++;
        }
        Object[] obj = result.toArray();
        int[] temp = new int[obj.length];
        for (int k = 0; k < obj.length; k++) {
            temp[k] = (int) obj[k];
        }
        return temp;
    }

    public static void main(String[] args) {
        IntersectionTwoArrays0349 ita0349 = new IntersectionTwoArrays0349();
        int[] nums1 = {4,4,9};
        int[] nums2 = {9,4,9,8,4};
        int[] nums3 = ita0349.intersection(nums1, nums2);
        System.out.println(Arrays.toString(nums3));
    }
}

/*
Arrays.copyOfRange();

public class Test {
    public static void main(String[] args) {
        int[] array = {0, 1, 2, 3, 4, 5, 6};
        int[] array2 = Arrays.copyOfRange(array, 2, 4);
        System.out.println(Arrays.toString(array2));
    }
}*/

33. 字符串中的第一个唯一字符

package com.lxh.simple;
/* 已通过 2021.10.13 时间 36ms 击败了9.39% 内存39MB 击败47.80%
* 想的太复杂了 在想到一种方法时 要想一想有没有更简便的方法
* HashMap散列表 不按进入顺序存储的 LinkedHashMap按照进入顺序
*
* 附 大神代码
* 注意总结 indexof()和lastIndexof()方法
* */
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

public class FirstUniqueCharacterString0387 {
    public int firstUniqChar(String s) {
        /*HashMap散列图、Hashtable散列表是按“有利于随机查找的散列(hash)的顺序”。
        并非按输入顺序。遍历时只能全部输出，而没有顺序。
        Map<Character, Integer> unique = new HashMap<>();*/
        //LinkedHashMap<>();按照输入顺序进入和输出
        Map<Character, Integer> unique = new LinkedHashMap<>();

        for (int i = 0; i < s.length(); i++) {
            if (unique.containsKey(s.charAt(i))) {
                unique.put(s.charAt(i), unique.get(s.charAt(i)) + 1);
            } else
                unique.put(s.charAt(i), 1);
        }

        Character temp = null;
        int flag = 1;
        for (Character key : unique.keySet()) {
            if (unique.get(key) == 1) {
                temp = key;
                flag = 0;
                break;
            }
        }
        if (flag == 1) {
            return -1;
        }

        int i = 0;
        for (i = 0; i < s.length(); i++) {
            if (temp == s.charAt(i)) {
                break;
            }
        }

        return i;
    }

    public static void main(String[] args) {
        FirstUniqueCharacterString0387 fucs0387 = new FirstUniqueCharacterString0387();
        String s1 = "leetcode";
        String s2 = "loveleetcode";
        String s3 = "aabb";

        System.out.println(fucs0387.firstUniqChar(s3));
    }
}

/* 执行用时为1ms的范例
class Solution {
    public int firstUniqChar(String s) {
        int minIndex = s.length();
        for(char i='a';i<='z';i++){
            //indexOf返回所查找字符串位置，找不到返回-1。
            int index = s.indexOf(i);
            if(index == -1) continue;

            if(index == s.lastIndexOf(i)) minIndex = Math.min(minIndex, index);
        }
        return minIndex != s.length()?minIndex:-1;
    }
}*/

34. 找不同
|=：两个二进制对应位都为0时，结果等于0，否则结果等于1；

&=：两个二进制的对应位都为1时，结果为1，否则结果等于0；

^=：两个二进制的对应位相同，结果为0，否则结果为1。

package com.lxh.simple;
/* 以通过 2021.12.13 时间15ms 击败6.11% 内存 37.1M 击败9.54%
* 这道题还是想复杂了 12.14号 思考一下更简便的方法
*
* 附 大神代码 和 很巧妙的思想代码
* 字符可以直接相加 直接相加时以ascii码相加
* */
import java.util.HashMap;
import java.util.Map;

public class FindDifference0389 {
    public char findTheDifference(String s, String t) {
        Map<Character, Integer> addLetter = new HashMap<>();
        String sumString = s + t;
        for (int i = 0; i < sumString.length(); i++) {
            if (addLetter.containsKey(sumString.charAt(i)))
                addLetter.put(sumString.charAt(i), addLetter.get(s.charAt(i)) + 1);
            else
                addLetter.put(sumString.charAt(i), 1);
        }

        Character temp = null;
        for (Character key : addLetter.keySet()) {
            if (addLetter.get(key) == 1)
                temp = key;
            break;
        }
        return temp;
    }

    public static void main(String[] args) {

    }
}

/* 大神代码
class Solution {
    public char findTheDifference(String s, String t) {
        char[] cs = s.toCharArray(), ct = t.toCharArray();
        int n = cs.length, a = ct[n];
        for (int i = 0; i < n; i++) {
            a ^= cs[i] ^ ct[i];
        }
        return (char) a;
    }
}*/

/* 思想很巧妙 字符可以直接加到int型里面的 因为多出来一个字符 每个字符串加在一起后 
   那差值就是多出来的那个字符的ASCII码
class Solution {
    public char findTheDifference(String s, String t) {
        int ss = 0;
        int ts = 0;
        for (char c : s.toCharArray()){
            ss += c;
        }

        for (char c : t.toCharArray()){
            ts += c;
        }

        return (char) (ts - ss);
    }
}*/

35. 最长和谐子序列

package com.lxh.simple;
/* 已通过 2021.10.17 时间16ms 击败72.76% 内存39.1M 击败86.20%
* 有多种做法 但自己不断尝试的过程中 会遇到新的问题 在遇到问题的时候要认真思考
* 看有没有更优的做法。
*
* */
import java.util.HashMap;
import java.util.Map;

public class LongestHarmoniousSubsequence0594 {
    public int findLHS(int[] nums) {

        int count = 0;
/*        //用作负数的时候出现了问题 可以将正负分开来调用 是负数时 加绝对值再调用
          //但这样感觉还是复杂了 故最终采用HashMap();
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < nums.length; i++) {
            if (Math.abs(nums[i]) > max)
                max = Math.abs(nums[i]);
        }
        int[] sum = new int[max + 1];
        for (int i = 0; i < nums.length; i++) {
            sum[Math.abs(nums[i])]++;
        }
        int count = 0;
        for (int i = 0; i < sum.length - 1; i++) {
            if (sum[i] != 0 && sum[i + 1] != 0)
                count = sum[i + 1] + sum[i] > count ? sum[i + 1] + sum[i] : count;
        }

        return count;
    }

    private int Computer*/
        Map<Integer, Integer> result = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (result.containsKey(nums[i])) {
                result.put(nums[i], result.get(nums[i]) + 1);
            } else {
                result.put(nums[i], 1);
            }
        }

        for (int x : result.keySet()) {
            if (result.containsKey(x + 1)) {
                count = result.get(x) + result.get(x + 1) > count ? result.get(x) + result.get(x + 1) : count;
            } else {
            }
        }
        return count;
    }


/*        //int max = nums[0];
        int min = nums[0];
        int i = 0, k = 0;
        //int j = 1;
        int middle = 0;
        int count = 0;
        boolean[] flag = new boolean[nums.length];

        for (i = 0; i < nums.length; i++) {
            if (!flag[i]) {
                for (int j = 0; j < nums.length;j++) {

                }
            }
            for (int j = 0; j < nums.length;j++) {
            if (nums[j] < min) {
                    min = nums[j];
                }
                if (max - min  <= 1) {
                    middle++;
                } else {
                    flag[k++] = j;
                }
            }
            count = middle > count ? middle : count;
            k = 0;
        }*/
       /* while(i < nums.length && j < nums.length) {
            if (nums[j] >= max) {
                max = nums[j];
            } else if (nums[j] <= min) {
                min = nums[j];
            }
            if (max - min  <= 1) {
                max = nums[j];
                count++;
                j++;
            } else {
                flag[];
            }
        }
    }*/

    public static void main(String[] args) {
        LongestHarmoniousSubsequence0594 lhs0594 = new LongestHarmoniousSubsequence0594();
        int[] nums = {-3,-2,1,2,3};
        System.out.println(lhs0594.findLHS(nums));
    }
}

36. 提莫攻击

package com.lxh.simple;
/* 已通过 2021.10.17 时间2ms 击败了91.67% 内存39.8MB 击败了95.56%
*  写此类简单的代码时 更细心认真一点 思考好整体结构后再动笔 争取一次性就正确完成
*
* */

public class TeemoAttacking0495 {
    public int findPoisonedDuration(int[] timeSeries, int duration) {
        int count = 0;
        int i;
        for (i = 0; i < timeSeries.length - 1; i++) {
            count += timeSeries[i] + duration > timeSeries[i+1] ? timeSeries[i+1] - timeSeries[i] : duration;
        }
        count += duration;

        return count;
    }

}

37. 下一个更大元素I

package com.lxh.simple;
/* 已通过 2021.10.17 时间2ms 击败98.97% 内存38.6MB 击败60.33%
*
*
*
* */
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class NextGreaterElementI0496 {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {

        Map<Integer, Integer> result = new HashMap<>();
        for (int i = 0 ; i < nums2.length; i++) {
            result.put(nums2[i], i);
        }
        int j;
        for (int i= 0; i < nums1.length; i++) {
            for (j = result.get(nums1[i]) + 1 ; j < nums2.length; j++) {
                if (nums2[j] > nums1[i]) {
                    nums1[i] = nums2[j];
                    break;
                }
            }
            if (j == nums2.length) {
                nums1[i] = -1;
            }
        }
        return nums1;
    }

    public static void main(String[] args) {
        NextGreaterElementI0496 ngeI0496 = new NextGreaterElementI0496();
        int[] nums1 = {4,1,2};
        int[] nums2 = {1,3,4,2};
        int[] nums3 = ngeI0496.nextGreaterElement(nums1, nums2);
        System.out.println(Arrays.toString(nums3));
    }
}

38. 种花问题

package com.lxh.simple;
/* 已通过 2021.10.17 时间1ms 击败91.36% 内存39.6MB 击败85.89%
*
*
*
* */
public class CanPlaceFlowers0605 {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        int count = 0;
        if (flowerbed.length == 1) {
            if (flowerbed[0] == 0)
                count += 1;
            if (count >= n)
                return true;
            else
                return false;
        }
        if (flowerbed[0] == 0 && flowerbed[1] == 0) {
            count += 1;
        }
        flowerbed[0] = 1;
        for (int i = 0; i < flowerbed.length -1; i += 2) {
            if (flowerbed[i] != 0) {}
            else if (flowerbed[i-1] != 1 && flowerbed[i+1] != 1){
                count++;
                flowerbed[i] = 1;
            }
        }
        if (flowerbed[flowerbed.length-1] == 0 && flowerbed[flowerbed.length-2] == 0) {
            count += 1;
        }
        if (count >= n)
            return true;
        else
            return false;
    }
}

39. 字符串中的单词数

package com.lxh.simple;
/* 已通过 2021.10.18 时间0ms 击败100% 内存36MB 击败86.37%
*
*
*
* */
public class NumberSegmentsString0434 {
    public int countSegments(String s) {
        int count = 0;
        if (s.length() == 0)
            return count;
        if (s.charAt(0) == ' ')
            count = 0;
        else
            count = 1;
        for (int i = 0; i < s.length()-1; i++) {
            if (s.charAt(i) == ' ' && s.charAt(i+1) != ' ') {
                count++;
            }
        }
        return count;
    }
}

40. 两数相除

package com.lxh.medium;
/* 2020.10.19 已通过 此题需要好好总结！
*
*
*
* */
public class DivideTwoIntegers0029 {
    public int divide(int dividend, int divisor) {
        if (dividend == 0x80000000 && divisor == -1)
            return Integer.MAX_VALUE;

        int flag = 0;

        if (dividend > 0) {
            dividend = -dividend;
            flag++;
        }
        if (divisor > 0) {
            divisor = -divisor;
            flag++;
        }

        int result = minusCircle(dividend, divisor);
        return flag == 1 ? -result : result;
    }

/* 可以成功 但超时
    private int minusCircle(int dividend, int divisor) {
        if (dividend == divisor)
            return 1;
        int count = -1;
        while (dividend <= 0) {
            count++;
            dividend = dividend - divisor;
        }
        return count;
    }*/

    private int minusCircle(int dividend, int divisor) {
        int result = 0;
        while (dividend <= divisor) {
            int value = divisor;
            int quotient = 1;
            while (value >= 0xc0000000 && dividend <= value + value) {
                quotient += quotient;
                value += value;
            }

            result += quotient;
            dividend -= value;
        }
        return result;
    }

    public static void main(String[] args) {
        DivideTwoIntegers0029 dti0029 = new DivideTwoIntegers0029();
        System.out.println(dti0029.divide(
                -2147483648,
                -2147483648));
    }
}

41. 有效的字母异位词

package com.lxh.simple;
/* 已通过 2021.10.20 好好总结
*  1. 字符串可以直接转换成字符数组；
*  2. 字符数组同样可以用sort函数进行排序
*  3. Arrays.equals() 可以直接比较字符串
*
*  4. 使用HashMap()进行解题。再优化HashMap再做一遍。
*  5. 将字符转换成数组再做一遍。
*
* */
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class ValidAnagram0242 {
    public boolean isAnagram(String s, String t) {
        /*if (s.length() != t.length())
            return false;

        Map<Character, Integer> sumLetterS = new HashMap<>();
        Map<Character, Integer> sumLetterT = new HashMap<>();

        for (int i = 0; i < s.length(); i++) {
            //
            sumLetterS.put(s.charAt(i), sumLetterS.getOrDefault(s.charAt(i), 0) + 1);
        }

        for (int i = 0; i < t.length(); i++) {
            sumLetterT.put(t.charAt(i), sumLetterT.getOrDefault(t.charAt(i), 0) + 1);
        }

        for (char x : sumLetterS.keySet()) {
            if (!sumLetterT.containsKey(x) || sumLetterS.get(x) != sumLetterT.get(x)) {
                return false;
            }
        }
        return true;
    }*/
        char[] sChars = s.toCharArray();
        char[] tChars = t.toCharArray();
        Arrays.sort(sChars);
        Arrays.sort(tChars);
        return Arrays.equals(sChars, tChars);

        // 一行解决战斗
        //return Arrays.equals(s.chars().sorted().toArray(), t.chars().sorted().toArray());
    }

}

42. 完美数

package com.lxh.simple;
/* 已通过 2021.10.20 时间401ms 击败40.80% 内存35.1MB 击败68.12%
*
*
* */

public class PerfectNumber0507 {
    public boolean checkPerfectNumber(int num) {

        if (num == 1)
            return false;
        int count = 1;
        int divisor = num;
        for (int i = 2; i < divisor; i++) {
            if (num % i == 0) {
                divisor = num / i;
                count += i + divisor;
            }
        }
        return count == num;
    }

    public static void main(String[] args) {
        PerfectNumber0507 pn0507 = new PerfectNumber0507();
        System.out.println(pn0507.checkPerfectNumber(28));
    }
}

43. 斐波那契数

package com.lxh.simple;
/* 已通过 2021.10.20 时间8ms 击败21.41% 内存35.1MB 击败59.26%
*
*
* */

public class FibonacciNumber0509 {
    public int fib(int n) {
        if (n == 0)
            return 0;
        if (n == 1)
            return 1;
        return fib(n-1) + fib(n-2);
    }

    public static void main(String[] args) {
        FibonacciNumber0509 fn0509 = new FibonacciNumber0509();
        System.out.println(fn0509.fib(4));
    }
}

44. 二分查找

package com.lxh.simple;
/* 已通过 时间0ms 击败100% 内存39.5MB 击败22.82%
*
* */

public class BinarySearch0704 {
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int middle;
        while(left <= right) {
            middle = (left+right) / 2;
            if (target == nums[middle])
                return middle;
            else if (target > nums[middle])
                left = middle + 1;
            else
                right = middle - 1;
        }
        return -1;
    }
}

45. 检查大写字母

package com.lxh.simple;
/* 已通过 2021.10.21 时间1ms 击败99.81% 内存36.9MB 击败26.47%
*
* */

public class DetectCapital0520 {
    public boolean detectCapitalUse(String word) {
        char[] chars = word.toCharArray();
        int count = 0;
        for (int i = 1; i < chars.length; i++) {
            if (chars[i] - 'a' >= 0) {
                count++;
            }
        }
        if (count == chars.length - 1) {
            return true;
        } else if (count == 0 && chars[0] - 'a' < 0) {
            return true;
        }else
            return false;
    }
}

46. 三个数的最大乘积

package com.lxh.simple;
/* 已通过 2021.10.21 时间12ms 击败13.50% 内存40MB 击败26.15%
*
*
* */
import java.util.Arrays;

public class MaximumProductThreeNumbers0628 {
    public int maximumProduct(int[] nums) {
        Arrays.sort(nums);
        int count = 0;
        int length = nums.length;
        int sumRight = nums[length-1]*nums[length-2]*nums[length-3];
        int sumLeft = nums[0] * nums[1] * nums[length-1];
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] < 0)
                count++;
            else
                break;
        }
        if (count <= 1) {
            return sumRight;
        }else
            //可以直接写成 return Math.max(sumRight, sumLeft);
            return sumRight >= sumLeft ? sumRight : sumLeft;
    }
}

47. 学生出勤记录I

package com.lxh.simple;
/* 已通过 2021.10.21 时间1ms 击败18.84% 内存36.2MB 击败91.42%
* Str.trim()用于删除字符串头尾空白符
* String[] strs = s.split(" ");将字符串strs按照空格分成字符串数组
* */
public class StudentAttendanceRecordI0551 {
    public boolean checkRecord(String s) {

        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == 'A')
                count++;
            else if (s.charAt(i) == 'L' && i+2 < s.length()) {
                String s1 = s.substring(i, i+3);
                if (s1.compareTo("LLL") == 0)
                    return false;
            }
        }
        if (count > 1)
            return false;
        return true;
    }

    public static void main(String[] args) {
        StudentAttendanceRecordI0551 sari0551 = new StudentAttendanceRecordI0551();
        System.out.println(sari0551.checkRecord("PPALLP"));
    }
}

48. 反转字符串中的单词III
总结StringBuilder和StringBuffer：
详细介绍String，StringBuilder和StringBuffer

package com.lxh.simple;
/* 已通过 2021.10.21 时间10ms 击败19.89% 内存39MB 击败54.20%
* 1.通过此题将StringBuilder和StringBuffer总结好
* 2.result.setLength(0);将result长度置为0，也就是将其置空。
*
* */
public class ReverseWordsStringIII0557 {
    public String reverseWords(String s) {

        StringBuffer result = new StringBuffer();
        StringBuffer getResult = new StringBuffer();

        for (char ch : s.toCharArray()) {
            if (ch != ' ') {
                result.append(ch);
            }else{
                getResult.append(result.reverse());
                getResult.append(' ');
                /*将result重置为空 还有一种
                int length = result.length();// 取得字符串的长度
                result.delete(0,length);    //删除字符串从0~sb_length-1处的内容 (这个方法就是用来清除StringBuffer中的内容的)*/
                result.setLength(0);
            }
        }

        getResult.append(result.reverse());

        return getResult.toString();
    }

    public static void main(String[] args) {
        ReverseWordsStringIII0557 rwsiii0557 = new ReverseWordsStringIII0557();
        System.out.println(rwsiii0557.reverseWords(" Let's take LeetCode contest"));
    }
}

49. 最长连续递增序列

package com.lxh.simple;
/* 已通过 2021.10.22 时间1ms 击败100% 内存39.2MB 击败42.27%
*
*
* */
public class LongestSubsequence0674 {
    public int findLengthOfLCIS(int[] nums) {
        int i= 0;
        int count = 1;
        int result = 1;
        while (i < nums.length - 1) {
            if (nums[i] < nums[i+1]) {
                count++;
            }else {
                count = 1;
            }
            i++;
            result = Math.max(result, count);
        }
        return result;
    }

    public static void main(String[] args) {
        LongestSubsequence0674 ls0674 = new LongestSubsequence0674();
        int[] nums = {1,3,5,4,7};
        System.out.println(ls0674.findLengthOfLCIS(nums));
    }
}

50. 子数组最大平均数I

package com.lxh.simple;
/* 已通过 2021.10.22 时间5ms 击败33.94% 内存52.1MB 击败61.65%
* 注意 Integer.MAX_VALUE和Integer.MIN_VALUE的使用
*
* */
public class MaximumAverageSubarrayI0643 {
    public double findMaxAverage(int[] nums, int k) {

        int i = 0;
        int j = 0;
        double count = 0;
        //当代码中出现需要大小比较之类的 要把被替换的换成最小和最大值去进行后续运算。
        double result = Integer.MIN_VALUE;
        while (i < nums.length) {
            if ((i - j) < k) {
                count += nums[i];
                i++;
            } else {
                result = Math.max(result, count / k);
                count -= nums[j];
                j++;
            }
        }

        result = Math.max(result, count / k);
        return result;
    }

    public static void main(String[] args) {
        MaximumAverageSubarrayI0643 masi0643 = new MaximumAverageSubarrayI0643();
        int[] nums = {-1};
        System.out.println(masi0643.findMaxAverage(nums, 1));
    }
}