刷题07 字符串easy

1869. 哪种连续子字符串更长

给你一个二进制字符串 s 。如果字符串中由 1 组成的 最长 连续子字符串 严格长于 由 0 组成的 最长 连续子字符串，返回 true ；否则，返回 false 。

• 例如，s = "110100010" 中，由 1 组成的最长连续子字符串的长度是 2 ，由 0 组成的最长连续子字符串的长度是 3 。

注意，如果字符串中不存在 0 ，此时认为由 0 组成的最长连续子字符串的长度是 0 。字符串中不存在 1 的情况也适用此规则。

输入：s = "1101"
输出：true

bool checkZeroOnes(char* s) {
    int max1=0,max2=0;
    int n=strlen(s);
    int i=0;
    while(i<n){
        if(s[i]=='1'){
            int cnt1=0;
            while(i<n&&s[i]=='1'){
                cnt1++;i++;
            }
            max1=fmax(max1,cnt1);
        }else{
            int cnt2=0;
            while(i<n&&s[i]=='0'){
                cnt2++;i++;
            }
            max2=fmax(max2,cnt2);
        }
    }
    return max1>max2;
}

1957. 删除字符使字符串变好

一个字符串如果没有 三个连续 相同字符，那么它就是一个 好字符串 。

给你一个字符串 s ，请你从 s 删除 最少 的字符，使它变成一个 好字符串 。

请你返回删除后的字符串。题目数据保证答案总是 唯一的 。

输入：s = "leeetcode"
输出："leetcode"
解释：
从第一组 'e' 里面删除一个 'e' ，得到 "leetcode" 。
没有连续三个相同字符，所以返回 "leetcode" 。

char* makeFancyString(char* s) {
    int n=strlen(s);
    if(n==1||n==2) return s;
    char* ans=malloc(sizeof(char)*(n+1));
    int idx=2;
    ans[0]=s[0];
    ans[1]=s[1];
    for(int j=2;j<n;++j){
        //不是连续3个字母就赋值给ans
        if(s[j]!=s[j-1]||s[j]!=s[j-2]){
            ans[idx++]=s[j];
            continue;
        }
    }
    ans[idx]='\0';
    return ans;
}

2110. 股票平滑下跌阶段的数目

给你一个整数数组 prices ，表示一支股票的历史每日股价，其中 prices[i] 是这支股票第 i 天的价格。

一个 平滑下降的阶段 定义为：对于 连续一天或者多天 ，每日股价都比 前一日股价恰好少 1 ，这个阶段第一天的股价没有限制。

请你返回 平滑下降阶段 的数目。

输入：prices = [3,2,1,4]
输出：7

long long getDescentPeriods(int* prices, int pricesSize){
    long long res=1;
    int prev=1;
    for(int i=1;i<pricesSize;++i){
        if(prices[i]==prices[i-1]-1){
            prev++;
        }else{
            prev=1;
        }
        res+=prev;
    }
    return res;
}

3005. 最大频率元素计数

给你一个由 正整数 组成的数组 nums 。

返回数组 nums 中所有具有 最大 频率的元素的 总频率 。

元素的 频率 是指该元素在数组中出现的次数。

输入：nums = [1,2,2,3,1,4]
输出：4

int maxFrequencyElements(int* nums, int numsSize) {
    int flag[102]={0};
    for(int i=0;i<numsSize;++i){
        flag[nums[i]]++;
    }
    int mmax=0;
    int ans=0;
    for(int i=0;i<102;++i){
        if(flag[i]>mmax){
            mmax=flag[i];
        }
    }
    for(int i=0;i<102;++i){
        if(flag[i]==mmax){
            ans+=flag[i];
        }
    }
    return ans;
}

409. 最长回文串

给定一个包含大写字母和小写字母的字符串 s ，返回 通过这些字母构造成的 最长的回文串 。

在构造过程中，请注意 区分大小写 。比如 "Aa" 不能当做一个回文字符串。

输入:s = "abccccdd"
输出:7
解释:
我们可以构造的最长的回文串是"dccaccd", 它的长度是 7。

int longestPalindrome(char * s){
    int flag[54]={0};
    int n=strlen(s);
    for(int i=0;i<n;++i){
        int c=s[i];
        if(c>='a'&&c<='z'){
            flag[c-'a']++;
        }else{
            flag[c-'A'+26]++;
        }
    }
    bool odd=false;
    int ans=0;
    for(int i=0;i<54;++i){
        if(flag[i]%2==0){
            ans+=flag[i];
        }else{
            ans+=flag[i]-1;
            odd=true;
        }
    }
    if(odd) ans+=1;
    return ans;
}

1221. 分割平衡字符串  

平衡字符串 中，'L' 和 'R' 字符的数量是相同的。给你一个平衡字符串 s，请你将它分割成尽可能多的子字符串，并满足：每个子字符串都是平衡字符串。

返回可以通过分割得到的平衡字符串的 最大数量 。

输入：s = "RLRRLLRLRL"
输出：4

int balancedStringSplit(char* s) {
    int ans=0,d=0;
    for(int i=0;i<strlen(s);++i){
        if(s[i]=='L'){
            d++;
        }else{
            d--;
        }
        if(d==0) ans++;
    }
    return ans;
}

1323. 6 和 9 组成的最大数字

给你一个仅由数字 6 和 9 组成的正整数 num。你最多只能翻转一位数字，将 6 变成 9，或者把 9 变成 6 。返回最大的数

输入：num = 9669
输出：9969

int maximum69Number (int num) {
    char* s=malloc(sizeof(char)*6);
    sprintf(s,"%d",num);
    int n=strlen(s);
    for(int i=0;i<n;++i){
        if(s[i]=='6'){
            s[i]='9';
            break;
        }
    }
    return atoi(s);
}

 
2160. 拆分数位后四位数字的最小和

 给你一个四位 正 整数 num 。请你使用 num 中的 数位 ，将 num 拆成两个新的整数 new1 和 new2 。new1 和 new2 中可以有 前导 0 ，且 num 中 所有 数位都必须使用。请你返回可以得到的 new1 和 new2 的 最小 和。

输入：num = 2932
输出：52
解释：最小和为数对 [29, 23] 的和：29 + 23 = 52 。

int cmp(char* a,char* b){
    return *a-*b;
}
int minimumSum(int num) {
    char* res=malloc(sizeof(char)*5);
    sprintf(res,"%d",num);
    qsort(res,4,sizeof(char),cmp);
    int new1=(res[0]-'0')*10+res[2]-'0';
    int new2=(res[1]-'0')*10+res[3]-'0';
    return new1+new2;
}

2259. 移除指定数字得到的最大结果

给你一个表示某个正整数的字符串 number 和一个字符 digit 。从 number 中 恰好 移除 一个 等于 digit 的字符后，找出并返回按 十进制 表示 最大 的结果字符串。

输入：number = "123", digit = "3"
输出："12"
解释："123" 中只有一个 '3' ，在移除 '3' 之后，结果为 "12" 。
输入：number = "1231", digit = "1"
输出："231"

我们从左至右遍历 number，如果遍历到 number[i]=digit，且number[i]<number[i+1]（如果存在，下同），则我们删除该字符后得到的结果最大；如果遍历完成依旧不存在满足上一个条件的下标，则我们删除 digit 出现的最后一个下标，此时删除该字符后得到的结果最大

char* removeDigit(char* number, char digit) {
    int n=strlen(number);
    int i=0;
    int idx=-1;
    while(i<n){
        if(number[i]==digit){
            idx=i;
            if(i<n&&number[i]<number[i+1]) break;
        }
        i++;
    }
    int l=0,r=0;
    while(r<n){
        if(r==idx){
           r++; 
        }else{
           number[l++]=number[r++]; 
        }
    }
    number[l]='\0';
    return number;
}

2566. 替换一个数字后的最大差值

给你一个整数 num 。你知道 Danny Mittal 会偷偷将 0 到 9 中的一个数字 替换 成另一个数字。

请你返回将 num 中 恰好一个 数字进行替换后，得到的最大值和最小值的差为多少。

输入：num = 11891
输出：99009
解释：
为了得到最大值，我们将数字 1 替换成数字 9 ，得到 99899 。
为了得到最小值，我们将数字 1 替换成数字 0 ，得到 890 。
两个数字的差值为 99009 。

int minMaxDifference(int num){
    char *s=malloc(sizeof(char)*10);
    sprintf(s,"%d",num);
    int n=strlen(s);
    int i=0,mmax,mmin;
    //找到第一个不是9的数字
    while(i<n&&s[i]=='9'){
        i++;
    }
    char target=s[i];
    //将所有这个数字替换为9
    for(int i=0;i<n;++i){
        if(s[i]==target){
            s[i]='9';
        }
    }
    mmax=atoi(s);
    sprintf(s,"%d",num);
    target=s[0];
    //将所有第一个数字替换为0
    for(int i=0;i<n;++i){
        if(s[i]==target){
            s[i]='0';
        }
    }
    mmin=atoi(s);
    return mmax-mmin;
}

2578. 最小和分割

给你一个正整数 num ，请你将它分割成两个非负整数 num1 和 num2 ，满足：

num1 和 num2 直接连起来，得到 num 各数位的一个排列。换句话说，num1 和 num2 中所有数字出现的次数之和等于 num 中所有数字出现的次数。num1 和 num2 可以包含前导 0 。请你返回 num1 和 num2 可以得到的和的 最小 值。

num 保证没有前导 0 。num1 和 num2 中数位顺序可以与 num 中数位顺序不同。

输入：num = 4325 输出：59 解释：我们可以将 4325 分割成 num1 = 24 和 num2 = 35 ，和为 59 ，59 是最小和。

         将num 的数字进行递增排序；按照递增顺序，交替地将数字分配给 num1 和 num2

int cmp(char *a, char *b) {
    return *a-*b;
}
int splitNum(int num) {
    char s[16];
    sprintf(s,"%d",num);
    int n = strlen(s);
    qsort(s,n,sizeof(char),cmp);
    int c1=0,c2=0;
    for(int i=0;i<n;++i){
        if(i%2==0){
            c1=c1*10+(s[i]-'0');
        }else{
            c2=c2*10+(s[i]-'0');
        }
    }
    return c1+c2;
}

2697. 字典序最小回文串

 给你一个由 小写英文字母 组成的字符串 s ，你可以对其执行一些操作。在一步操作中，你可以用其他小写英文字母 替换  s 中的一个字符。

请你执行 尽可能少的操作 ，使 s 变成一个 回文串 。如果执行 最少 操作次数的方案不止一种，则只需选取 字典序最小 的方案。

对于两个长度相同的字符串 a 和 b ，在 a 和 b 出现不同的第一个位置，如果该位置上 a 中对应字母比 b 中对应字母在字母表中出现顺序更早，则认为 a 的字典序比 b 的字典序要小。

返回最终的回文字符串。

输入：s = "egcfe"
输出："efcfe"
解释：将 "egcfe" 变成回文字符串的最小操作次数为 1 ，修改 1 次得到的字典序最小回文字符串是 "efcfe"，只需将 'g' 改为 'f' 。

char * makeSmallestPalindrome(char * s){
    int n=strlen(s);
    int l=0,r=n-1;
    while(l<r){
        if(s[l]!=s[r]){
            s[l]=s[r]=fmin(s[l],s[r]);
        }
        l++;r--;
    }
    return s;
}

2864. 最大二进制奇数

 给你一个 二进制 字符串 s ，其中至少包含一个 '1' 。

你必须按某种方式 重新排列 字符串中的位，使得到的二进制数字是可以由该组合生成的 最大二进制奇数 。以字符串形式，表示并返回可以由给定组合生成的最大二进制奇数。

输入：s = "010"
输出："001"
解释：因为字符串 s 中仅有一个 '1' ，其必须出现在最后一位上。所以答案是 "001" 。

char* maximumOddBinaryNumber(char* s){
    int n=strlen(s);
    int cnt=0;
    for(int i=0;i<n;++i){
        if(s[i]=='1'){
            cnt++;
        }
    }
    int i=0;
    while(i<n-1){
        if(cnt>1){
            cnt--;
            s[i++]='1';
        }else{
            s[i++]='0';
        }
    }
    s[i]='1';
    return s;
}

1768. 交替合并字符串

给你两个字符串 word1 和 word2 。请你从 word1 开始，通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长，就将多出来的字母追加到合并后字符串的末尾。

返回 合并后的字符串 。

输入：word1 = "abc", word2 = "pqr"
输出："apbqcr"
解释：字符串合并情况如下所示：
word1：  a   b   c
word2：    p   q   r
合并后：  a p b q c r

char * mergeAlternately(char * word1, char * word2){
    int n=strlen(word1),m=strlen(word2);
    char* ans=malloc(sizeof(char)*(1000));
    int pos=0;
    for(int i=0;i<n||i<m;++i){
        if(i<n){
            ans[pos++]=word1[i];  
        }
        if(i<m){
            ans[pos++]=word2[i];
        }
    }
    ans[pos]='\0';//不要忘最后加上休止符，否则要溢出
    return ans;
}