leetcode字符串篇(10题已完成）

最新推荐文章于 2022-04-15 16:36:33 发布

smile_study1

最新推荐文章于 2022-04-15 16:36:33 发布

阅读量453

点赞数

分类专栏：刷题

本文链接：https://blog.csdn.net/smile_study1/article/details/105613705

版权

刷题专栏收录该内容

23 篇文章 0 订阅

订阅专栏

简单

1

383. 赎金信

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

注意：

你可以假设两个字符串均只含有小写字母。

canConstruct(“a”, “b”) -> false
canConstruct(“aa”, “ab”) -> false
canConstruct(“aa”, “aab”) -> true

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int len1 = ransomNote.length();
        if(len1==0)
        return true;
        int len2 = magazine.length();
        if(len2==0||len1>len2)
        return false;
        int[] arr= new int[len2];
        for(int i=0;i<len1;i++){
            char c = ransomNote.charAt(i);
            boolean flag = false;
            for(int j=0;j<len2;j++){
                char tmp = magazine.charAt(j);
                if(c==tmp&&arr[j]==0){
                    arr[j]=1;
                    flag=true;
                    break;
                }
            }
            if(!flag)
            return false;
        }
        return true;
    }
}

2

459. 重复的子字符串

给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。

示例 1:

输入: “abab”

输出: True

解释: 可由子字符串 “ab” 重复两次构成。
示例 2:

输入: “aba”

输出: False
示例 3:

输入: “abcabcabcabc”

输出: True

解释: 可由子字符串 “abc” 重复四次构成。 (或者子字符串 “abcabc” 重复两次构成。)

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        char[] arr = s.toCharArray();

        int index=1;
        while(index<=arr.length/2){
                boolean flag = true;
            for(int i=0;i<arr.length-index;i++){
                int tmp=i;

                while(tmp+index<arr.length){
                    if(arr[tmp]!=arr[tmp+index]){
                        flag=false;
                        break;
                    }
                    tmp+=index;
                }
                if(!flag)
                break;
            }
            if(flag&&arr.length%index==0)
            return true;
            index++;
        }
        return false;
    }
}

3

434. 字符串中的单词数

统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。

请注意，你可以假定字符串里不包括任何不可打印的字符。

示例:

输入: “Hello, my name is John”
输出: 5
解释: 这里的单词是指连续的不是空格的字符，所以 “Hello,” 算作 1 个单词。
思路：如果字符串为空，那么返回0，否则维护两个变量，一个统计单词个数，一个统计单词长度，遇到空格时，若长度不为0，那么代表此前有一个单词，ans加1，并且将cnt清零，结束后判断最后的cnt是否不为0，不为0则ans加1

class Solution {
    public int countSegments(String s) {
        char[] arr = s.toCharArray();
        if(arr.length==0)
        return 0;
        int cnt=0;
        int ans = 0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]==' '){
                if(cnt!=0)
                ans++;
                cnt=0;
            }else{
                cnt++;
            }
        }
        if(cnt!=0)
        ans++;
        return ans;
    }
}

4

917. 仅仅反转字母

给定一个字符串 S，返回 “反转后的” 字符串，其中不是字母的字符都保留在原地，而所有字母的位置发生反转。

示例 1：

输入：“ab-cd”
输出：“dc-ba”
示例 2：

输入：“a-bC-dEf-ghIj”
输出：“j-Ih-gfE-dCba”
示例 3：

输入：“Test1ng-Leet=code-Q!”
输出：“Qedo1ct-eeLg=ntse-T!”

class Solution {
    public String reverseOnlyLetters(String S) {
        StringBuilder sb = new StringBuilder();
        StringBuilder ans = new StringBuilder();
        int len = S.length();
        char[] cc = S.toCharArray();
        for(int i=len-1;i>=0;i--){
            if(cc[i]>='a'&&cc[i]<='z')
            sb.append(cc[i]);
           if(cc[i]>='A'&&cc[i]<='Z')
            sb.append(cc[i]);
        }
        int index=0;
        for(int i=0;i<len;i++){
      if(cc[i]>='a'&&cc[i]<='z'){
            ans.append(sb.charAt(index));
            index++;
      }
          else if(cc[i]>='A'&&cc[i]<='Z'){
            ans.append(sb.charAt(index));
            index++;
           }
            else{
                ans.append(cc[i]);
            }
        }
        return ans.toString();
    }
}

5

443. 压缩字符串

给定一组字符，使用原地算法将其压缩。

压缩后的长度必须始终小于或等于原数组长度。

数组的每个元素应该是长度为1 的字符（不是 int 整数类型）。

在完成原地修改输入数组后，返回数组的新长度。

进阶：
你能否仅使用O(1) 空间解决问题？

class Solution {
    public int compress(char[] chars) {
        int index = 0;
        int cnt=1;
        char tmp = chars[0];
        for(int i=0;i<chars.length-1;i++){
            tmp=chars[i+1];
            if(chars[i]==chars[i+1]){
                cnt++;
                
            }else{
                chars[index++]=chars[i];
                if(cnt>1){
                    String aa = "";
                while(cnt>0){
                    aa+=cnt%10;
                    cnt/=10;
                }
                for(int j=aa.length()-1;j>=0;j--){
                    chars[index++]=aa.charAt(j);
                }
                }

                cnt=1;
            }

        }
        chars[index++]=tmp;
                if(cnt>1){
                    String aa = "";
                while(cnt>0){
                    aa+=cnt%10;
                    cnt/=10;
                }
                for(int j=aa.length()-1;j>=0;j--){
                    chars[index++]=aa.charAt(j);
                }
                }
        return index--;
    }
}

6

520. 检测大写字母

给定一个单词，你需要判断单词的大写使用是否正确。

我们定义，在以下情况时，单词的大写用法是正确的：

全部字母都是大写，比如"USA"。
单词中所有字母都不是大写，比如"leetcode"。
如果单词不只含有一个字母，只有首字母大写，比如 “Google”。
否则，我们定义这个单词没有正确使用大写字母。

示例 1:

输入: “USA”
输出: True
示例 2:

输入: “FlaG”
输出: False

class Solution {
    public boolean detectCapitalUse(String word) {
        char[] arr= word.toCharArray();
        boolean flag = false;
        int cnt0=0;
        int cnt1=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]>='a'&&arr[i]<='z'){
                cnt0++;
            }
            if(arr[i]>='A'&&arr[i]<='Z'){
                if(i==0)
                flag=true;
                cnt1++;
            }
        }
        if(cnt1==arr.length||(flag&&cnt1==1)||cnt0==arr.length)
        return true;
        return false;
    }
}

7

541. 反转字符串 II

给定一个字符串和一个整数 k，你需要对从字符串开头算起的每个 2k 个字符的前k个字符进行反转。如果剩余少于 k 个字符，则将剩余的所有全部反转。如果有小于 2k 但大于或等于 k 个字符，则反转前 k 个字符，并将剩余的字符保持原样。

示例:

输入: s = “abcdefg”, k = 2
输出: “bacdfeg”

class Solution {
    public String reverseStr(String s, int k) {
        int len = s.length();
        int index=0;
        StringBuilder sb = new StringBuilder();
        while(index<len){
            if((index+2*k)<len){
                for(int i=k-1;i>=0;i--){
                    sb.append(s.charAt(i+index));

                }
                index+=k;
                for(int i=0;i<k;i++){
                    sb.append(s.charAt(i+index));
                }
                index+=k;
            }
            else if((index+k)<len){
                for(int i=k-1;i>=0;i--){
                    sb.append(s.charAt(i+index));

                }
                index+=k;
                while(index<len)
                sb.append(s.charAt(index++));
            }
            else {
                for(int i=len-1;i>=index;i--)
                sb.append(s.charAt(i));
                index=len;
            }
        }
        return sb.toString();
    }
}

8

521. 最长特殊序列 Ⅰ

给你两个字符串，请你从这两个字符串中找出最长的特殊序列。

「最长特殊序列」定义如下：该序列为某字符串独有的最长子序列（即不能是其他字符串的子序列）。

子序列可以通过删去字符串中的某些字符实现，但不能改变剩余字符的相对顺序。空序列为所有字符串的子序列，任何字符串为其自身的子序列。

输入为两个字符串，输出最长特殊序列的长度。如果不存在，则返回 -1。

示例 1：

输入: “aba”, “cdc”
输出: 3
解释: 最长特殊序列可为 “aba” (或 “cdc”)，两者均为自身的子序列且不是对方的子序列。
示例 2：

输入：a = “aaa”, b = “bbb”
输出：3
示例 3：

输入：a = “aaa”, b = “aaa”
输出：-1

class Solution {
    public int findLUSlength(String a, String b) {
        if(a.equals(b))
        return -1;
        return Math.max(a.length(),b.length());
    }
}

9

551. 学生出勤记录 I

给定一个字符串来代表一个学生的出勤记录，这个记录仅包含以下三个字符：

‘A’ : Absent，缺勤
‘L’ : Late，迟到
‘P’ : Present，到场
如果一个学生的出勤记录中不超过一个’A’(缺勤)并且不超过两个连续的’L’(迟到),那么这个学生会被奖赏。

你需要根据这个学生的出勤记录判断他是否会被奖赏。

示例 1:

输入: “PPALLP”
输出: True
示例 2:

输入: “PPALLL”
输出: False
思路：该题重点在于记录连续两次迟到，即L的次数，重点是连续，注意审题，遇到A、P的话，需要清零

class Solution {
    public boolean checkRecord(String s) {
        int len = s.length();
        int cnt1=0;
        int cnt2=0;
        for(int i=0;i<len;i++){
            if(s.charAt(i)=='A'){
            cnt1++;
            cnt2=0;
            if(cnt1>1)
            return false;
            }else
            if(s.charAt(i)=='L'){
            cnt2++;
            if(cnt2>2)
            return false;
            }else {
                cnt2=0;
            }


        }
        if(cnt1<=1&&cnt2<=2)
        return true;
        return false;
    }
}

10

125. 验证回文串

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

说明：本题中，我们将空字符串定义为有效的回文串。

示例 1:

输入: “A man, a plan, a canal: Panama”
输出: true
示例 2:

输入: “race a car”
输出: false

class Solution {
    public boolean isPalindrome(String s) {
        if("".equals(s))
        return true;
        String tmp="";
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)>='a'&&s.charAt(i)<='z')
            tmp+=s.charAt(i);
            if(s.charAt(i)>='A'&&s.charAt(i)<='Z')
            tmp+=s.charAt(i);
            if(s.charAt(i)>='0'&&s.charAt(i)<='9')
            tmp+=s.charAt(i);
        }
        int len = tmp.length()/2;
        for(int i=0;i<len;i++){
            char a = tmp.charAt(i);
            char b = tmp.charAt(tmp.length()-1-i);
            if(a>='0'&&a<='9'||b>='0'&&b<='9'){
                if(a!=b)
                return false;
            }
            if(a==b||Math.abs(a-b)==Math.abs('A'-'a')){
                continue;
            }else{
                return false;
            }
        }
        return true;
    }
}

smile_study1

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
leetcode字符串篇(10题已完成）

简单1383. 赎金信给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)注意：...
复制链接

扫一扫