# 【英雄算法六月集训】Day05

升序排序，减少点时间复杂度，因为这样窗口最右侧的数据都是比较大的 左侧比较小的

然后循环，只要窗口右侧没到达数组最右侧边界，则继续循环

1. 每次循环判断，窗口大小是否大于k，大了，左侧边界往后移动1 缩小下窗口
2. 窗口大小为k 做分析，分析出来的数和暂存的最小差值作比较，取最小
3. 然后窗口右边界移动，继续探测下一个可能的最小值

class Solution {
    public int minimumDifference(int[] nums, int k) {
       int n = nums.length;
       Arrays.sort(nums);
       int i=0,j=0;
       int ans=Integer.MAX_VALUE;
       while(j<=n){
           if(j-i>k){
               ++i;
           }
           if(i+j==k){
              ans = Math.min(ans,nums[j-1]-nums[i]); 
           }
           ++j;
       }
       return ans;
    }
}

class Solution {
    public int code(char c){
        if(c>='a' && c <= 'z'){
            return c -'a';
        }
        return c - 'A'+26;
    }
    public String longestNiceSubstring(String s) {
        int n = s.length();
        int l,i,j,k;
        int[]  hash ;
        for(l = n;l>0;--l){
            i = 0;
            j = -1;
            hash = new int[52];
            while(j < n-1){
                ++j;
                ++hash[code(s.charAt(j))];
                while(j-i+1 > l){
                    --hash[code(s.charAt(i))];
                    ++i;
                }

                if(j-i+1 == l){
                    for(k=0;k<26;++k){
                        if(hash[k]>=1&&hash[k+26]<=0){
                            break;
                        }else if(hash[k]<=0&&hash[k+26]>=1){
                            break;
                        }
                    }
                    if(k==26){
                        String tmp =  s.substring(i,i+j-i+1);
                        return tmp;
                    }
                }

            }

        }
        return "";
    }
}

JAVA API 截取字符串 转数字。然后计算

class Solution {
    public int divisorSubstrings(int num, int k) {
      String numStr = String.valueOf(num);
      int j;
      int ret=0;
      for(int i=0;i+k <= numStr.length();++i){
         j=i+k;
         String subNum = numStr.substring(i,j);
         System.out.println(subNum);
         Integer realNum = Integer.valueOf(subNum);
         if(realNum!=0){
            if(num % realNum ==0){
                ++ret;
            }
         }
      }
        return ret;
    }
}

class Solution {
    int[]  a = new int[100010];
    public int minKBitFlips(int[] nums, int k) {
         int ans = 0,sum=0;
         for(int i=0;i < nums.length;++i){
             sum^=a[i];
             sum&=1;
             if(((sum+nums[i])&1) == 0){
                 if(i+k > nums.length){
                     return -1;
                 }
                 a[i]^=1;
                 a[i+k]^=1;
                 ++ans;
                 sum^=1;
             }
         }
         return ans;
    }
}