力扣刷题 day5

长度最小的子数组

 

209. 长度最小的子数组 - 力扣（LeetCode）
 

java :

 // 长度最小的子数组
    public static int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int right = 0;
        int len = Integer.MAX_VALUE;
        int count = 0;
        while (right < nums.length) {
            // 进窗口
            count += nums[right];
            // 判断
            while (count >= target) {
                len = Math.min(len, right - left + 1);
                // 出窗口
                count -= nums[left++];
            }
            right++;
        }
        return len == Integer.MAX_VALUE ? 0 : len;
    }

python：

class Solution(object):
    # 长度最小的子数组
    def minSubArrayLen(self, target, nums):
        left, right, count, length = 0, 0, 0, sys.maxsize
        while right < len(nums):
            # 进窗口
            count += nums[right]
            while count >= target:
                length = min(length, right - left + 1)
                count -= nums[left]
                left += 1
            right += 1
        # python 中的三目
        return 0 if length == sys.maxsize else length

 

无重复字符的最长子串

 

3. 无重复字符的最长子串 - 力扣（LeetCode）

java:

class Solution {
  // 最长不重复子串 使用 String 来判断重复
    public int lengthOfLongestSubstring1(String s) {
        int left = 0;
        int right = 0;
        String str = "";
        int len = 0;
        while (right < s.length()) {
            char temp = s.charAt(right);
            while (!str.contains(temp + "")) {
                str += temp;
                right++;
                if(right >= s.length()){
                    break;
                }
                temp = s.charAt(right);
            }
            len = Math.max(len, right - left);
            // 此时找到相等的了
            while (s.charAt(left) != temp) {
                left++;
            }
            left++;
            str = s.substring(left, right);
        }
        return len;
    }
    
    // 使用 hash 
    
    public int lengthOfLongestSubstring2(String s) {
        char[] strArray = s.toCharArray();
        // 标准的ASCII 差不多有 128 个字符,创建一个数组来模拟成hahs
        int[] hash = new int[128];
        int left = 0;
        int right = 0;
        int n = s.length();
        int len = 0;
        while (right < n) {
            // 进入窗口
            hash[strArray[right]]++;
            // 判断
            while (hash[strArray[right]] > 1) {
                // 此时说明重复了--> 出窗口
                hash[strArray[left++]]--;
            }
            // 没有重复,算出字串的长度
            len = Math.max(len, right - left + 1);
            right++;
        }
        return len;
    }
}

 
python:

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        left, right, n, size = 0, 0, len(s), 0
        hash = [0] * 128
        while right < n:
            hash[ord(s[right])] += 1
            while hash[ord(s[right])] > 1:
                hash[ord(s[left])] -= 1
                left += 1
            size = max(size, right - left + 1)
            right += 1
        return size