编程练习

尽可能使字符串相等

给你两个长度相同的字符串，s 和 t。

将 s 中的第 i 个字符变到 t 中的第 i 个字符需要 |s[i] - t[i]| 的开销（开销可能为 0），也就是两个字符的 ASCII 码值的差的绝对值。

用于变更字符串的最大预算是 maxCost。在转化字符串时，总开销应当小于等于该预算，这也意味着字符串的转化可能是不完全的。

如果你可以将 s 的子字符串转化为它在 t 中对应的子字符串，则返回可以转化的最大长度。

如果 s 中没有子字符串可以转化成 t 中对应的子字符串，则返回 0。

示例 1：

输入：s = “abcd”, t = “bcdf”, cost = 3
输出：3
解释：s 中的 “abc” 可以变为 “bcd”。开销为 3，所以最大长度为 3。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/get-equal-substrings-within-budget
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

int equalSubstring(char * s, char * t, int maxCost){
    int start = 0;
    int cnt = 0;
    int len = strlen(s);
    int i;

    for(i=0;i<len;i++){
        cnt += abs(s[i]-t[i]);
        if(cnt>maxCost){
            cnt -= abs(s[start]-t[start]);
            start++;
        }
    }
    return len-start;
}

删除字符串中的所有相邻重复项 II

给你一个字符串 s，「k 倍重复项删除操作」将会从 s 中选择 k 个相邻且相等的字母，并删除它们，使被删去的字符串的左侧和右侧连在一起。

你需要对 s 重复进行无限次这样的删除操作，直到无法继续为止。

在执行完所有删除操作后，返回最终得到的字符串。

本题答案保证唯一。

示例 1：

输入：s = “abcd”, k = 2
输出：“abcd”
解释：没有要删除的内容。
示例 2：

输入：s = “deeedbbcccbdaa”, k = 3
输出：“aa”
解释：
先删除 “eee” 和 “ccc”，得到 “ddbbbdaa”
再删除 “bbb”，得到 “dddaa”
最后删除 “ddd”，得到 “aa”

char * removeDuplicates(char * s, int k){
    int len;
    int start;
    int i,j;
    char flag = 0;
    
    len = strlen(s);
    start = 0;
    for(i=0;i<len;){
        for(j=i;j<i+k;j++){
        	if((j+k)>len) break;
            if(s[j]!=s[i]){
                break;
            }
        }
        //找到k个相同字符
        if(j==i+k){
            i = j;
            flag = 1;
        }else{
            s[start++]=s[i++];
        }
    } 
    s[start]='\0';
    if(flag == 0){
        return s;
    }

    return removeDuplicates(s,k);
}

char * removeDuplicates(char * s, int k){
    int len;
    int cnt=0;
    int i,j;
    int di;
    char flag = 0;

    len = strlen(s);
    for(di=0,i=0;i<len;i++,di++){
        s[di] = s[i];
        if(di==0){
            cnt = 1;
        }
        else if(s[di-1]!=s[di]){
            cnt = 1;
        }else{
            cnt++;
        }
        if(cnt==k){
            di = di-k;
            cnt=1;
            flag =1;
        }
    }
    s[di]='\0';
    if(flag == 0) return s;

    return removeDuplicates(s,k);
}

形成目标数组的子数组最少增加次数

给你一个整数数组 target 和一个数组 initial ，initial 数组与 target 数组有同样的维度，且一开始全部为 0 。

请你返回从 initial 得到 target 的最少操作次数，每次操作需遵循以下规则：

在 initial 中选择 任意 子数组，并将子数组中每个元素增加 1 。
答案保证在 32 位有符号整数以内。

示例 1：

输入：target = [1,2,3,2,1]
输出：3
解释：我们需要至少 3 次操作从 intial 数组得到 target 数组。
[0,0,0,0,0] 将下标为 0 到 4 的元素（包含二者）加 1 。
[1,1,1,1,1] 将下标为 1 到 3 的元素（包含二者）加 1 。
[1,2,2,2,1] 将下表为 2 的元素增加 1 。
[1,2,3,2,1] 得到了目标数组。

int minNumberOperations(int* target, int targetSize){
    int n = targetSize;
    int i,d=0;
    int t=target[0];
    for(i=1;i<n;i++){
        d = target[i]-target[i-1];
        if(d>0)
            t += d;
    }
    return t;
}

最小覆盖子串

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 “” 。

注意：如果 s 中存在这样的子串，我们保证它是唯一的答案。

示例 1：

输入：s = “ADOBECODEBANC”, t = “ABC”
输出：“BANC”
示例 2：

输入：s = “a”, t = “a”
输出：“a”

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-window-substring

char * minWindow(char * s, char * t){
    int tc['z'-'A'+1]={0};
    int tlen=0;
    int i;
    for(i=0;t[i]!='\0';i++){
        tc[t[i]-'A'] += 1;
        //printf("%d  ",tc[t[i]-'A']);
        tlen += 1;
    }

    char index;
    int left=0;
    int minleft=0,minright=-1;
    for(i=0;s[i]!='\0';i++){
        index = s[i]-'A';
        if(tc[index]>0){
            tlen--;
        }
        tc[index]--;

        if(tlen==0){
            while(tc[s[left]-'A']<0){
                tc[s[left]-'A']++;
                left++;
            }
            if((minright==-1) || (i-left < minright-minleft)){
                minleft = left;
                minright = i;
            }
            tc[s[left]-'A']++;
            tlen++;
            left++;
        }
    }
    s[minright+1]='\0';
    
    return s+minleft;
}

替换子串得到平衡字符串

有一个只含有 ‘Q’, ‘W’, ‘E’, ‘R’ 四种字符，且长度为 n 的字符串。

假如在该字符串中，这四个字符都恰好出现 n/4 次，那么它就是一个「平衡字符串」。

给你一个这样的字符串 s，请通过「替换一个子串」的方式，使原字符串 s 变成一个「平衡字符串」。

你可以用和「待替换子串」长度相同的 任何 其他字符串来完成替换。

请返回待替换子串的最小可能长度。

如果原字符串自身就是一个平衡字符串，则返回 0。

示例 1：

输入：s = “QWER”
输出：0
解释：s 已经是平衡的了。
示例 2：

输入：s = “QQWE”
输出：1
解释：我们需要把一个 ‘Q’ 替换成 ‘R’，这样得到的 “RQWE” (或 “QRWE”) 是平衡的。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/replace-the-substring-for-balanced-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

int balancedString(char * s){
    int cn['W'-'E'+1]={0};
    int i,j;
    int left=0;
    int len =0;
    int avg = 0;
    //统计各个字符的数量
    for(i=0;s[i]!='\0';i++){
        printf("%c",s[i]);
        cn[s[i]-'E']++;
        len++;
    }
    avg = len>>2;

    int min = len;
    //滑动窗口内包含超出平均个数的数量的字符。
    //窗口外的字符的统计数应小于等于平均值
    for(i=0;s[i]!='\0';i++){
        cn[s[i]-'E']--;
        //满足条件就不断移动left，缩小窗口
        while((cn['Q'-'E']<=avg) && (cn['W'-'E']<=avg) &&
            (cn['E'-'E']<=avg) && (cn['R'-'E']<=avg) ){
                if(i-left+1 < min){
                    min = i-left+1;
                }
                if(left>i){
                    break;
                }
                cn[s[left]-'E']++;
                left++;
            }
    }
    return min;
}

int balancedString(char * s){
    int cn['W'-'E'+1]={0};
    int i;
    int left=0;
    int len =0;
    int avg = 0;
    //统计各个字符的数量
    for(i=0;s[i]!='\0';i++){
        printf("%c",s[i]);
        cn[s[i]-'E']++;
        len++;
    }
    avg = len>>2;
    int tlen = 0;
    for(i='E';i<='W';i++){
        if(cn[i-'E']>avg){
            tlen = tlen+cn[i-'E']-avg;
        }
    }

    int min = len;
    //滑动窗口内包含超出平均个数的数量的字符。
    //窗口外的字符的统计数应小于等于平均值
    for(i=0;s[i]!='\0';i++){
        if(cn[s[i]-'E'] > avg){
            tlen--;
        }
        cn[s[i]-'E']--;

        //当tlen等于0时，说明，所有个数大于平均值的字符在窗口外的个数小于等于平均值了
        //满足条件就不断移动left，缩小窗口
        if(tlen==0){
            while((left<=i) && (cn[s[left]-'E']<avg)){
                cn[s[left]-'E']++;
                left++;
            }
            if(i-left+1<min){
                min = i-left+1;
            }
            if(left<=i){
                cn[s[left]-'E']++;
                tlen++;
                left++;
            }
        }
    }
    return min;   
}

非递减数列

给你一个长度为 n 的整数数组，请你判断在 最多 改变 1 个元素的情况下，该数组能否变成一个非递减数列。

我们是这样定义一个非递减数列的： 对于数组中所有的 i (0 <= i <= n-2)，总满足 nums[i] <= nums[i + 1]。

示例 1:

输入: nums = [4,2,3]
输出: true
解释: 你可以通过把第一个4变成1来使得它成为一个非递减数列。

bool checkPossibility(int* nums, int numsSize){
    int i =0;
    int n = numsSize;
    int cnt=0;
    
    for(i=1;i<numsSize;i++){
        if(nums[i-1]>nums[i]){
            cnt++;
            if(cnt>1){
                return false;
            }
            if(i==1 || i==numsSize-1){
                continue;
            }
            if(nums[i-2]>nums[i] && nums[i-1]>nums[i+1]){
                return false;
            }
        }
    }
    return true;
}

数组的度

给定一个非空且只包含非负数的整数数组 nums，数组的度的定义是指数组里任一元素出现频数的最大值。

你的任务是在 nums 中找到与 nums 拥有相同大小的度的最短连续子数组，返回其长度。

示例 1：

输入：[1, 2, 2, 3, 1]
输出：2
解释：
输入数组的度是2，因为元素1和2的出现频数最大，均为2.
连续子数组里面拥有相同度的有如下所示:
[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]
最短连续子数组[2, 2]的长度为2，所以返回2.

int cnt[50000];

int findShortestSubArray(int* nums, int numsSize){
    int i;
    int ret=numsSize;
    int maxcnt=0;
    int r=0;
    int l=0;

    //查找最大的度
    memset(cnt,0,sizeof(cnt));
    for(i=0;i<numsSize;i++){
        cnt[nums[i]]++;
        maxcnt = fmax(maxcnt, cnt[nums[i]]);
    }

    //滑动窗口
    memset(cnt,0,sizeof(cnt));
    for(r=0;r<numsSize;r++){
        cnt[nums[r]]++;
        while(cnt[nums[r]]==maxcnt){
            ret=fmin(ret,r-l+1);
            cnt[nums[l]]--;
            l++;
        }
    }
    return ret;
}

检查两个字符串数组是否相等

给你两个字符串数组 word1 和 word2 。如果两个数组表示的字符串相同，返回 true ；否则，返回 false 。

数组表示的字符串 是由数组中的所有元素 按顺序 连接形成的字符串。

示例 1：

输入：word1 = [“ab”, “c”], word2 = [“a”, “bc”]
输出：true
解释：
word1 表示的字符串为 “ab” + “c” -> “abc”
word2 表示的字符串为 “a” + “bc” -> “abc”
两个字符串相同，返回 true

bool arrayStringsAreEqual(char ** word1, int word1Size, char ** word2, int word2Size){
    int i1=0,i2=0;
    int j1=0,j2=0;
    bool ret = false;

    while(i1<word1Size && i2<word2Size){
        if(word1[i1][j1]!=word2[i2][j2]){
            break;
        }

        j1++;
        if(word1[i1][j1]=='\0'){
            i1++;
            j1=0;
        }

        j2++;
        if(word2[i2][j2]=='\0'){
            i2++;
            j2=0;
        }
    }

    if(i1==word1Size && i2==word2Size){
        ret = true;
    }
    return ret;
}

具有给定数值的最小字符串

小写字符 的 数值 是它在字母表中的位置（从 1 开始），因此 a 的数值为 1 ，b 的数值为 2 ，c 的数值为 3 ，以此类推。

字符串由若干小写字符组成，字符串的数值 为各字符的数值之和。例如，字符串 “abe” 的数值等于 1 + 2 + 5 = 8 。

给你两个整数 n 和 k 。返回 长度 等于 n 且 数值 等于 k 的 字典序最小 的字符串。

注意，如果字符串 x 在字典排序中位于 y 之前，就认为 x 字典序比 y 小，有以下两种情况：

x 是 y 的一个前缀；
如果 i 是 x[i] != y[i] 的第一个位置，且 x[i] 在字母表中的位置比 y[i] 靠前。

示例 1：

输入：n = 3, k = 27
输出：“aay”
解释：字符串的数值为 1 + 1 + 25 = 27，它是数值满足要求且长度等于 3 字典序最小的字符串。

char * getSmallestString(int n, int k){
    char *res ;
    int rest,bound;

    res = (char *)malloc(100000);
    memset(res,0,100000);

    for(rest=n;rest>=1;rest--){
        bound = k-26*(rest-1);
       
        if(bound>0){
            res[n-rest] = bound+'a'-1;
            k -= bound;
        }else{
            res[n-rest] = 'a';
            k-=1;
        }
    }
    return res;
}

char res[100000]={0};

char * getSmallestString(int n, int k){
    int i;
    int zs;
    int lev;
    //首先全部设置a
    memset(res,'a',n);
    res[n]='\0';

    //z的个数
    zs = (k-n)/25;
    //剩余值
    lev = (k-n)%25;

    for(i=1;i<=zs;i++){
        res[n-i]='z';
    }
    if(lev!=0){
        res[n-i] += lev;
    }
    
    return res;
}

生成平衡数组的方案数

给你一个整数数组 nums 。你需要选择 恰好 一个下标（下标从 0 开始）并删除对应的元素。请注意剩下元素的下标可能会因为删除操作而发生改变。

比方说，如果 nums = [6,1,7,4,1] ，那么：

选择删除下标 1 ，剩下的数组为 nums = [6,7,4,1] 。
选择删除下标 2 ，剩下的数组为 nums = [6,1,4,1] 。
选择删除下标 4 ，剩下的数组为 nums = [6,1,7,4] 。
如果一个数组满足奇数下标元素的和与偶数下标元素的和相等，该数组就是一个 平衡数组 。

请你返回删除操作后，剩下的数组 nums 是 平衡数组 的 方案数 。

示例 1：

输入：nums = [2,1,6,4]
输出：1
解释：
删除下标 0 ：[1,6,4] -> 偶数元素下标为：1 + 4 = 5 。奇数元素下标为：6 。不平衡。
删除下标 1 ：[2,6,4] -> 偶数元素下标为：2 + 4 = 6 。奇数元素下标为：6 。平衡。
删除下标 2 ：[2,1,4] -> 偶数元素下标为：2 + 4 = 6 。奇数元素下标为：1 。不平衡。
删除下标 3 ：[2,1,6] -> 偶数元素下标为：2 + 6 = 8 。奇数元素下标为：1 。不平衡。
只有一种让剩余数组成为平衡数组的方案。

int waysToMakeFair(int* nums, int numsSize){
    int h1=0,h2=0;
    int t1=0,t2=0;
    int i;
    int cnt=0;

    for(i=0;i<numsSize;i++){
        if((i&1)==0){
            t2+=nums[i];
        }else{
            t1+=nums[i];
        }
    }
    //printf("t1:%d, t2:%d ",t1,t2);
    for(i=0;i<numsSize;i++){
        if((i&1)==0){
            t2-=nums[i];
            if(h2+t1==h1+t2){
                cnt++;
            }
            h2+=nums[i];
        }else{
            t1-=nums[i];
            if(h2+t1==h1+t2){
                cnt++;
            }
            h1+=nums[i];
        }
    }
    return cnt;
}