刷题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(imax2;
}


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


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


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;immax){
            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='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


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

 
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](如果存在,下同),则我们删除该字符后得到的结果最大;如果遍历完成依旧不存在满足上一个条件的下标,则我们删除 digit 出现的最后一个下标,此时删除该字符后得到的结果最大

char* removeDigit(char* number, char digit) {
    int n=strlen(number);
    int i=0;
    int idx=-1;
    while(i


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


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

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


2864. 最大二进制奇数

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

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

输入:s = "010"
输出:"001"
解释:因为字符串 s 中仅有一个 '1' ,其必须出现在最后一位上。所以答案是 "001" 。
char* maximumOddBinaryNumber(char* s){
    int n=strlen(s);
    int cnt=0;
    for(int i=0;i1){
            cnt--;
            s[i++]='1';
        }else{
            s[i++]='0';
        }
    }
    s[i]='1';
    return s;
}

你可能感兴趣的:(leetcode刷题打卡,java,算法,javascript)