刷题10

2833. 距离原点最远的点

给你一个长度为 n 的字符串 moves ，该字符串仅由字符 'L'、'R' 和 '_' 组成。字符串表示你在一条原点为 0 的数轴上的若干次移动。

• 如果 moves[i] = 'L' 或 moves[i] = '_' ，可以选择向左移动一个单位距离
• 如果 moves[i] = 'R' 或 moves[i] = '_' ，可以选择向右移动一个单位距离

移动 n 次之后，请你找出可以到达的距离原点 最远 的点，并返回 从原点到这一点的距离 。

输入：moves = "L_RL__R"
输出：3
解释：可以到达的距离原点 0 最远的点是 -3 ，移动的序列为 "LLRLLLR" 。

int furthestDistanceFromOrigin(char * moves){
    int l=0,r=0,cnt=0;
    int ans=0;
    for(int i=0;i<strlen(moves);++i){
        if(moves[i]=='L'){
            l++;
        }else if(moves[i]=='R'){
            r++;
        }else{
            cnt++;
        }
    }
    ans=abs(l-r)+cnt;
    return ans;
}

1790. 仅执行一次字符串交换能否使两个字符串相等

给你长度相等的两个字符串 s1 和 s2 。一次 字符串交换 操作的步骤如下：选出某个字符串中的两个下标（不必不同），并交换这两个下标所对应的字符。

如果对 其中一个字符串 执行 最多一次字符串交换 就可以使两个字符串相等，返回 true ；否则，返回 false 。

输入：s1 = "bank", s2 = "kanb"
输出：true
解释：例如，交换 s2 中的第一个和最后一个字符可以得到 "bank"

int strncmp ( const char * str1, const char * str2, size_t n );功能是把 str1 和 str2 进行比较，最多比较前 n 个字节，若str1与str2的前n个字符相同，则返回0；若s1大于s2，则返回大于0的值；若s1 小于s2，则返回小于0的值 

void swap(char *s,int i,int j){
    char tmp=s[i];
    s[i]=s[j];
    s[j]=tmp;
    return;
}
bool areAlmostEqual(char* s1, char* s2) {
    int n=strlen(s1),m=strlen(s2);
    if(n!=m) return false;
    if(strncmp(s1,s2,n)==0) return true;
    //枚举交换的两个下标
    for(int i=0;i<n;++i){
        for(int j=i+1;j<n;++j){
            //交换
            swap(s2,i,j);
            //判断
            if(strncmp(s1,s2,n)==0){
                return true;
            }
            //恢复
            swap(s2,i,j);
        }
    }
    return false;
}

2068. 检查两个字符串是否几乎相等 

 如果两个字符串 word1 和 word2 中从 'a' 到 'z' 每一个字母出现频率之差都 不超过 3 ，那么我们称这两个字符串 word1 和 word2 几乎相等 。

给你两个长度都为 n 的字符串 word1 和 word2 ，如果 word1 和 word2 几乎相等 ，请你返回 true ，否则返回 false 。

一个字母 x 的出现 频率 指的是它在字符串中出现的次数。

输入：word1 = "aaaa", word2 = "bccb"
输出：false
解释：字符串 "aaaa" 中有 4 个 'a' ，但是 "bccb" 中有 0 个 'a' 。
两者之差为 4 ，大于上限 3 。

bool checkAlmostEquivalent(char* word1, char* word2) {
    int flag[26]={0};
    int n=strlen(word1),m=strlen(word2);
    for(int i=0;i<n;++i){
        flag[word1[i]-'a']++;
    }
    for(int i=0;i<m;++i){
        flag[word2[i]-'a']--;
    }
    for(int i=0;i<26;++i){
        //绝对值不大于3
        if(abs(flag[i])>3) return false;
    }
    return true;
}

2287. 重排字符形成目标字符串 

 给你两个下标从 0 开始的字符串 s 和 target 。你可以从 s 取出一些字符并将其重排，得到若干新的字符串。

从 s 中取出字符并重新排列，返回可以形成 target 的 最大 副本数。

输入：s = "ilovecodingonleetcode", target = "code"
输出：2
解释：
对于 "code" 的第 1 个副本，选取下标为 4 、5 、6 和 7 的字符。
对于 "code" 的第 2 个副本，选取下标为 17 、18 、19 和 20 的字符。

int rearrangeCharacters(char* s, char* target) {
    int sCounts[26], targetCounts[26];
    memset(sCounts, 0, sizeof(sCounts));
    memset(targetCounts, 0, sizeof(targetCounts));
    int n = strlen(s), m = strlen(target);
    for (int i = 0; i < m; i++) {
        targetCounts[target[i]-'a']++;
    }
    //记录目的字段中各个字母出现的频数
    for (int i = 0; i < n; i++) {
        if (targetCounts[s[i]-'a']) {
            sCounts[s[i]-'a']++;
        }
    }
    int ans = INT_MAX;
    for (int i = 0; i < 26; i++) {
        if (targetCounts[i] > 0) {
            //每次记录最小可以组成目的字段的次数
            ans = fmin(ans, sCounts[i] / targetCounts[i]);
            //只有一个字母的次数为0
            if (ans == 0) {
                return 0;
            }
        }
    }
    return ans;
}

1400. 构造 K 个回文字符串 

 给你一个字符串 s 和一个整数 k 。请你用 s 字符串中 所有字符 构造 k 个非空 回文串 。

如果你可以用 s 中所有字符构造 k 个回文字符串，那么请你返回 True ，否则返回 False 。

输入：s = "annabelle", k = 2
输出：true
解释：可以用 s 中所有字符构造 2 个回文字符串。
一些可行的构造方案包括："anna" + "elble"，"anbna" + "elle"，"anellena" + "b"

bool canConstruct(char * s, int k){
    //字符串s最少可以构造的回文串个数 left
    //最多可以构造的回文串个数right；
    //s的长度>=k 并且 s中奇数字符的个数<=k即满足要求
    //k在left和right之间返回true
    int n=strlen(s);
    int flag[26]={0};
    for(int i=0;i<n;++i){
        flag[s[i]-'a']++;
    }
    int left=0,right=n;
    for(int i=0;i<26;++i){
        if(flag[i]%2==1){
            left++;
        }
    }
    left=fmax(left,1);
    return left<=k&&k<=right;
}

231. 2 的幂 

 给你一个整数 n，请你判断该整数是否是 2 的幂次方。如果是，返回 true ；否则，返回 false 。

如果存在一个整数 x 使得 n == 2x ，则认为 n 是 2 的幂次方。

输入：n = 16
输出：true
解释：24 = 16

bool isPowerOfTwo(int n) {
    if(n==0) return false;
    bool flag=false;
    if(n<0) flag=true;
    int cnt=0;
    while(n>1){
        if(n%2==1) return false;
        n/=2;
        cnt++;
    }
    if(flag&&cnt%2==0) return false; 
    return true;
}