NC刷题笔记7-字符串

已于 2022-04-05 19:59:12 修改
阅读量384 收藏
点赞数
文章标签： 算法 数据结构
于 2022-04-02 14:18:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34329430/article/details/123919234
版权

NC刷题笔记7-字符串

本博客文章（学习笔记）导航 （点击这里访问）
在这里插入图片描述

NC1 大数加法

描述
以字符串的形式读入两个数字，编写一个函数计算它们的和，以字符串形式返回。

数据范围：len(s),len(t),len(s),len(t)≤100000，字符串仅由'0'~‘9’构成
要求：时间复杂度 O(n)

示例1
输入："1","99"
返回值："100"
说明：1+99=100     

示例2
输入："114514",""
返回值："114514"

思路：
	合并数组

import java.util.  ;


public class Solution {
    /    
        代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
        计算两个数之和
        @param s string字符串 表示第一个整数
        @param t string字符串 表示第二个整数
        @return string字符串
       /
    public String solve (String s, String t) {
        // write code here
        int sLength=s.length();
        int tLength=t.length();
        int minLength=Math.min(sLength,tLength);
        s=reverse(s);
        t=reverse(t);
        StringBuilder sb=new StringBuilder();
        int addNum=0;
        for(int i=0;i<minLength;i++){
            int sNum=(int)(s.charAt(i)-'0');
            int tNum=(int)(t.charAt(i)-'0');
            int nummy=sNum+tNum+addNum;
            addNum=(int)(nummy/10);
            sb.append(nummy%10+"");
        }
        if(sLength>minLength){
            for(int i=minLength;i<sLength;i++){
                int sNum=(int)(s.charAt(i)-'0');
                int nummy=sNum+addNum;
                addNum=(int)(nummy/10);
                sb.append(nummy%10+"");
            }
        }
        if(tLength>minLength){
            for(int i=minLength;i<tLength;i++){
                int sNum=(int)(t.charAt(i)-'0');
                int nummy=sNum+addNum;
                addNum=(int)(nummy/10);
                sb.append(nummy%10+"");
            }
        }
        if(addNum!=0) sb.append(addNum+"");
        sb=sb.reverse();
        String res=sb.toString();
        for(int i=0;i<res.length();i++){
            if(res.charAt(i)!='0') return res.substring(i,res.length());
        }
        return res;
    }
    
    public String reverse(String str){
        return new StringBuilder(str).reverse().toString();
    }
}

NC10 大数乘法

描述
以字符串的形式读入两个数字，编写一个函数计算它们的乘积，以字符串形式返回。
数据范围： 读入的数字大小满足0≤n≤10^1000
要求：空间复杂度 O(n)，时间复杂度 O(n^2)
示例1  输入："11","99"  返回值："1089"  说明：11  99=1089 
示例2  输入："1","0"  返回值："0"

import java.util.  ;
public class Solution {
    public String solve (String s, String t) {
        String res="0";
        for(int i=0;i<t.length();i++){
            char c=t.charAt(i);
            int n=t.length()-1-i;
            String temp=twoNummultiply(s,c,n);
            res=twoNumsum(res,temp);
        }
        return res;
    }
    
    public String twoNummultiply(String s,char c,int n){
        if(c=='0') return "0";
        int mulNum=(int)(c-'0');
        StringBuilder sb=new StringBuilder();
        int addNum=0;
        for(int i=s.length()-1;i>=0;i--){
            int sNum=(int)(s.charAt(i)-'0');
            int temp=sNum  mulNum+addNum;
            addNum=(int)(temp/10);
            sb.append(temp%10);
        }
        if(addNum!=0) sb.append(addNum);
        sb=sb.reverse();
        while(n>0){
            sb.append("0");
            n--;
        }
        return sb.toString();
    }
    
    public String twoNumsum(String s,String t){
        int sLength=s.length();
        int tLength=t.length();
        int minLength=Math.min(sLength,tLength);
        s=reverse(s);
        t=reverse(t);
        StringBuilder sb=new StringBuilder();
        int addNum=0;
        for(int i=0;i<minLength;i++){
            int sNum=(int)(s.charAt(i)-'0');
            int tNum=(int)(t.charAt(i)-'0');
            int nummy=sNum+tNum+addNum;
            addNum=(int)(nummy/10);
            sb.append(nummy%10+"");
        }
        if(sLength>minLength){
            for(int i=minLength;i<sLength;i++){
                int sNum=(int)(s.charAt(i)-'0');
                int nummy=sNum+addNum;
                addNum=(int)(nummy/10);
                sb.append(nummy%10+"");
            }
        }
        if(tLength>minLength){
            for(int i=minLength;i<tLength;i++){
                int sNum=(int)(t.charAt(i)-'0');
                int nummy=sNum+addNum;
                addNum=(int)(nummy/10);
                sb.append(nummy%10+"");
            }
        }
        if(addNum!=0) sb.append(addNum+"");
        sb=sb.reverse();
        String res=sb.toString();
        for(int i=0;i<res.length();i++){
            if(res.charAt(i)!='0') return res.substring(i,res.length());
        }
        return res;
    }
    
    public String reverse(String str){
        return new StringBuilder(str).reverse().toString();
    }
}

NC17 最长回文子串

描述
对于长度为n的一个字符串A（仅包含数字，大小写英文字母），请设计一个高效算法，计算其中最长回文子串的长度。
数据范围：1≤n≤1000
要求：空间复杂度 O(1)，时间复杂度 O(n^2)
进阶:  空间复杂度 O(n)，时间复杂度 O(n)

示例1 输入："ababc"  返回值：3
说明：最长的回文子串为"aba"与"bab"，长度都为3
示例2 输入："abbba"  返回值：5
示例3  输入："b" 返回值：1

思路1：
	两层for循环，依次判断i和j之间是不是回文
思路2：
	中心扩散法（奇数和偶数）

import java.util.  ;

public class Solution {
    public int getLongestPalindrome(String A) {
        // write code here
        char[] chars=A.toCharArray();
        int maxlength=0;
        for(int i=0;i<chars.length;i++){
            for(int j=i;j<chars.length;j++){
                if(judge(i,j,chars)) maxlength=Math.max(maxlength,j-i+1);
            }
        }
        return maxlength;
    }
    
    public boolean judge(int i,int j,char[] chars){
        if(i==j) return true;
        while(i<j){
            if(chars[i]!=chars[j]) return false;
            i++;
            j--;
        }
        return true;
    }
}

import java.util.  ;
public class Solution {
    public int getLongestPalindrome (String A) {
        // write code here
        if(A.length()==0||A.length()==1) return A.length();
        int res=1;
        for(int i=0;i<A.length();i++){
            res=Math.max(res,Longest(i,A));
        }
        return res;
    }
    
    public int Longest(int i,String A){
        //奇数
        int left=i,right=i,res=1;
        while(left>=0&&right<A.length()){
            if(A.charAt(left)==A.charAt(right)){
                res=Math.max(right-left+1,res);
                left--;
                right++;
            }else{
                break;
            }
        }
        //偶数
       if((i+1)<A.length() && A.charAt(i+1)==A.charAt(i)){
           left=i-1;
           right=i+2;
           res=Math.max(2,res);
           while(left>=0&&right<A.length()){
                if(A.charAt(left)==A.charAt(right)){
                    res=Math.max(right-left+1,res);
                    left--;
                    right++;
                }else{
                    break;
                }
           }
       }
       return res;
    }
}

NC20 数字字符串转化成IP地址

描述
现在有一个只包含数字的字符串，将该字符串转化成IP地址的形式，返回所有可能的情况。
例如：给出的字符串为"25525522135",
返回["255.255.22.135", "255.255.221.35"]. (顺序没有关系)
数据范围：字符串长度0≤n≤12
要求：空间复杂度 O(n!),时间复杂度 O(n!)
注意：ip地址是由四段数字组成的数字序列，格式如 "x.x.x.x"，其中 x 的范围应当是 [0,255]。

示例1
输入："25525522135"
返回值：["255.255.22.135","255.255.221.35"]

示例2
输入："1111"
返回值：["1.1.1.1"]

示例3
输入："000256"
返回值："[]"

思路1：
	暴力枚举，每一个位包含一到三位字符
	如果四个位置相加为s.length

思路2：
	递归回溯

import java.util.  ;
public class Solution {
    public ArrayList<String> restoreIpAddresses (String s) {
        ArrayList<String> list = new ArrayList();
        for(int a=1; a<4; a++){
            for(int b=1; b<4; b++){
                for(int c=1; c<4; c++){
                    for(int d=1; d<4; d++){
                        if(a+b+c+d==s.length()){
                            String s1 = s.substring(0, a);
                            String s2 = s.substring(a, a+b);
                            String s3 = s.substring(a+b, a+b+c);
                            String s4 = s.substring(a+b+c, a+b+c+d);
                            if(check(s1)&&check(s2)&&check(s3)&&check(s4)){
                                String ip = s1+"."+s2+"."+s3+"."+s4;
                                list.add(ip);
                            }
                        }
                    }
                }
            }
        }
        return list;
    }
    
    public boolean check(String s){
        if(Integer.valueOf(s)<=255){
            if(s.charAt(0)!='0' || s.charAt(0)=='0'&&s.length()==1) 
                return true;
        }
        return false;
    }
}

思路2：
import java.util.  ;
public class Solution {
    public ArrayList<String> restoreIpAddresses (String s) {
        if (s.length() > 12) {
            return null;
        }
        StringBuilder sb = new StringBuilder(s);
        doRestoreIpAddresses(sb, 1);
        return ans;
    }
    ArrayList<String> ans = new ArrayList<>();
    public void doRestoreIpAddresses(StringBuilder s, int m) { // 回溯暴力算法，还要很多地方没有剪枝
        String[] nums = s.toString().split("\\.");
        if (nums.length > 4) { // 剪枝
            return;
        }
        if (validateIPv4(s.toString())) { // 结束条件
            ans.add(String.copyValueOf(s.toString().toCharArray()));
            return;
        }

        for (int i = m; i < s.length(); i++) { // 回溯
            s.insert(i, "."); 
            doRestoreIpAddresses(s, i + 2);
            s.replace(i, i + 1, "");

        }
    }
    
     public boolean validateIPv4(String IP) {
        String[] nums = IP.split("\\.");
        if (nums.length !=  4) {
            return false;
        }
        for (String x : nums) {
            // 0-255:
            if (x.length() == 0 || x.length() > 3) return false;
            // 0的情况
            if (x.charAt(0) == '0' && x.length() != 1) return false;
            // 大于255
            if (Integer.parseInt(x) > 255) return false;
        }
        return true;
    }
}

BM83 字符串变形

描述
对于一个长度为 n 字符串，我们需要对它做一些变形。
首先这个字符串中包含着一些空格，就像"Hello World"一样，然后我们要做的是把这个字符串中由空格隔开的单词反序，同时反转每个字符的大小写。
比如"Hello World"变形后就变成了"wORLD hELLO"。
数据范围: 1≤n≤10^6, 字符串中包括大写英文字母、小写英文字母、空格。
进阶：空间复杂度 O(n)， 时间复杂度 O(n)

输入描述：给定一个字符串s以及它的长度n(1 ≤ n ≤ 10^6)
返回值描述：请返回变形后的字符串。题目保证给定的字符串均由大小写字母和空格构成。

示例1
输入："This is a sample",16
返回值："SAMPLE A IS tHIS"

示例2
输入："nowcoder",8
返回值："NOWCODER"

思路：
	1 用StringBuilder和Stack来做
	2 遇到空格就把 StringBuilder的东西入栈并清空StringBuilder
	3 遇到其他字符就放在StringBuilder中
	4 最后把栈里的元素弹出来，后面拼空格
	5 再把最后一个空格删掉

import java.util.  ;

public class Solution {
    public String trans(String s, int n) {
        // write code here
        //使用栈的特性，输出为反向
        Stack<String>stack=new Stack<>();
        StringBuffer buffer=new StringBuffer();
        for(int i=0;i<n;i++){
            //遇到空格入栈
            if(s.charAt(i)==' '){
                stack.push(buffer.toString());
                buffer.delete(0,buffer.length());
            }else{
                //小写字母-32转为大写
                if(s.charAt(i)>='a'&&s.charAt(i)<='z'){
                    buffer.append((char)(s.charAt(i)-32));
                }else{
                    //大写字母+32转为小写
                    buffer.append((char)(s.charAt(i)+32));
                }
            }
        }
        //最后一个单词入栈
        stack.push(buffer.toString());
        StringBuffer ans=new StringBuffer();
        while(!stack.isEmpty()){
            ans.append(stack.pop());
            //每个单词后接空格
            ans.append(' ');
        }
        //删除最后一个多余空格
        ans.deleteCharAt(ans.length()-1);
        return ans.toString();
    }
}

BM84 最长公共前缀

描述
给你一个大小为 n 的字符串数组 strs ，其中包含n个字符串 , 编写一个函数来查找字符串数组中的最长公共前缀，返回这个公共前缀。数据范围：0≤n≤5000， 0≤len(strs i)≤5000
进阶：空间复杂度 O(n)，时间复杂度 O(n)

示例1
输入：["abca","abc","abca","abc","abcc"]
返回值："abc"

示例2
输入：["abc"]
返回值："abc"

思路：
	1 先按照字典序排序
	2 比较第一个和最后一个的公共前缀

import java.util.  ;
public class Solution {
    public String longestCommonPrefix (String[] strs) {
        if(strs==null||strs.length==0) return "";
        Arrays.sort(strs);
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<strs[0].length();i++){
            if(strs[0].charAt(i)==strs[strs.length-1].charAt(i)){
                sb.append(strs[0].charAt(i));
            }else{
                break;
            }
        }
        return sb.toString();
    }
}

BM85 验证IP地址

描述
编写一个函数来验证输入的字符串是否是有效的 IPv4 或 IPv6 地址
IPv4 地址由十进制数和点来表示，每个地址包含4个十进制数，其范围为 0 - 255， 用(".")分割。比如，172.16.254.1；
同时，IPv4 地址内的数不会以 0 开头。比如，地址 172.16.254.01 是不合法的。

IPv6 地址由8组16进制的数字来表示，每组表示 16 比特。这些组数字通过 (":")分割。比如,  2001:0db8:85a3:0000:0000:8a2e:0370:7334 是一个有效的地址。而且，我们可以加入一些以 0 开头的数字，字母可以使用大写，也可以是小写。所以， 2001:db8:85a3:0:0:8A2E:0370:7334 也是一个有效的 IPv6 address地址 (即，忽略 0 开头，忽略大小写)。

然而，我们不能因为某个组的值为 0，而使用一个空的组，以至于出现 (::) 的情况。 比如， 2001:0db8:85a3::8A2E:0370:7334 是无效的 IPv6 地址。
同时，在 IPv6 地址中，多余的 0 也是不被允许的。比如， 02001:0db8:85a3:0000:0000:8a2e:0370:7334 是无效的。

说明: 你可以认为给定的字符串里没有空格或者其他特殊字符。
数据范围：字符串长度满足5≤n≤50
进阶：空间复杂度 O(n)，时间复杂度 O(n)

示例1
输入："172.16.254.1"
返回值："IPv4"
说明：这是一个有效的 IPv4 地址, 所以返回 "IPv4" 

示例2
输入："2001:0db8:85a3:0:0:8A2E:0370:7334"
返回值："IPv6"
说明：这是一个有效的 IPv6 地址, 所以返回 "IPv6" 

示例3
输入："256.256.256.256"
返回值："Neither"
说明：这个地址既不是 IPv4 也不是 IPv6 地址

注意事项
	2 分割字符串时，使用limit = -1的split函数，使得字符串末尾或开头有一个'.'或':'也能分割出空的字符串
	2 使用Integer.parseInt()函数检查异常
	3 startsWith("0")方法判断以"0"为开头

import java.util.  ;
public class Solution {
    public String solve(String IP) {
        return validIPv4(IP) ? "IPv4" : (validIPv6(IP) ? "IPv6" : "Neither");
    }

    private boolean validIPv4(String IP) {
        String[] strs = IP.split("\\.", -1);
        if (strs.length != 4) {
            return false;
        }

        for (String str : strs) {
            if (str.length() > 1 && str.startsWith("0")) {
                return false;
            }
            try {
                int val = Integer.parseInt(str);
                if (!(val >= 0 && val <= 255)) {
                    return false;
                }
            } catch (NumberFormatException numberFormatException) {
                return false;
            }
        }
        return true;
    }

    private boolean validIPv6(String IP) {
        String[] strs = IP.split(":", -1);
        if (strs.length != 8) {
            return false;
        }

        for (String str : strs) {
            if (str.length() > 4 || str.length() == 0) {
                return false;
            }
            try {
                int val = Integer.parseInt(str, 16);
            } catch (NumberFormatException numberFormatException) {
                return false;
            }
        }
        return true;
    }
}

BM86 大数加法

描述
以字符串的形式读入两个数字，编写一个函数计算它们的和，以字符串形式返回。数据范围：len(s),len(t)≤100000，字符串仅由'0'~‘9’构成
要求：时间复杂度 O(n)

示例1
输入："1","99"
返回值："100"
说明：1+99=100      

示例2
输入："114514",""
返回值："114514"

思路：
	合并链表的类似做法
	1 反转两条字符串
	2 合并字符串
	3 反转结果

import java.util.  ;

public class Solution {
    public String solve (String s, String t) {
        StringBuilder s0=new StringBuilder(s);
        StringBuilder t0=new StringBuilder(t);
        s=s0.reverse().toString();
        t=t0.reverse().toString();
        int add=0,i=0,j=0;
        StringBuilder res=new StringBuilder();
        while(i<s.length()&&j<t.length()){
            int sum=(int)(s.charAt(i)-'0')+(int)(t.charAt(j)-'0')+add;
            res.append(sum%10+"");
            add=sum/10;
            i++;
            j++;
        }
        
        while(i<s.length()){
            int sum=(int)(s.charAt(i)-'0')+add;
            res.append(sum%10+"");
            add=sum/10;
            i++;
        }
        
        while(j<t.length()){
            int sum=(int)(t.charAt(j)-'0')+add;
            res.append(sum%10+"");
            add=sum/10;
            j++;
        }
        
        if(add!=0) res.append(add+"");
        return res.reverse().toString();
    }
}
CandyDingDing
关注
专栏目录
BM83 字符串变形
rgdggf的博客
05-25 163
描述 对于一个长度为 n字符串，我们需要对它做一些变形。 首先这个字符串中包含着一些空格，就像"Hello World"一样，然后我们要做的是把这个字符串中由空格隔开的单词反序，同时反转每个字符的大小写。 比如"Hello World"变形后就变成了"wORLD hELLO"。 数据范围:1\le n \le 10^61≤n≤106, 字符串中包括大写英文字母、小写英文字母、空格。 进阶：空间复杂度O(n)O(n)， 时间复杂度O(n)O(n) 输入描述： 给定一个字符...
刷题记录----字符串
HandsomeDog_L的博客
07-30 265
字符串的相关题目，反转，kmp
牛客网刷题笔记（一）
weixin_43964189的博客
03-20 298
牛客网刷题笔记
编程题刷题笔记（包括leetcode和各种公司笔试题）
weixin_38104825的博客
07-06 4567
7/6：     做的查找中的word_ladder，没做出来。         学到了的知识点：             unordered_set：                 定义为unordered_set&lt;string&gt;dict                 在集合中查找为dict.find(cur_front)，找没找到用if (dict.find(cur_...
[BUUCTF]Pwn刷题记录
x0r
10-13 228
本部分内容长期更新，不再创建新文章影响阅读 rip 根据IDA加载入main函数声明发现s数组距离rbp的距离为F，即为15，这里的运行环境是64位，所以应当将Caller's rbp的数据填满，在这里是8位，即可构造payload from pwn import * p=remote("node4.buuoj.cn", 25401) #p=process("./pwn1") payload=b...
2024年前端最全从网易与淘宝的font-size思考前端设计稿与工作流，Github标星5.3K
最新发布
2401_84435192的博客
05-06 838
疯狂编程学习效果可视化写博客阅读优秀代码心态调整。
有用的工具续
weixin_34014277的博客
08-25 5713
前文 markdown https://ivarptr.github.io/yu-...Typora https://www.typora.io/ http://mark.uxwin.com/https://wordmarkapp.com/ 单词库 http://www.xsdict.cn/ 去广告 Hosts https://githu...
牛客网——C++——BM83 字符串变形
qq_50555834的博客
03-19 179
BM83字符串变形
牛客BM83 字符串变形
萧海的博客
05-07 281
描述 示例1 输入： "This is a sample",16 返回值： "SAMPLE A IS tHIS" 示例2 输入： "nowcoder",8 返回值： "NOWCODER" 示例3 输入： "iOS",3 返回值： "Ios" 主要思路：全部遍历添加到vector Code: class Solution { public: string trans(string s, int n) { vector<string>vec; vector&.
牛客 BM83 字符串变形（大小写转换，字符串反转，字符串替换）
weixin_43971252的博客
06-29 557
字符串反转，截取子串，字符串替换，大小写转换
字符串习题总结1
weixin_47651920的博客
04-15 1424
一.最长公共子序列（动态规划） 1.题目说明 一个字符串的子序列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。 两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。 2.图解说明 3.代码实现 //求最长公共子序列 public int longestCommonSubseq....
C++——数组与字符串
享受孤独
08-16 1475
目录 一、数组 1.1定义与初始化 1.1.1语法形式 1.1.2使用 1.1.3存储 1.1.4初始化 1.2作函数参数 1.3对象数组 1.3.1定义与访问 1.3.2初始化 1.3.3数组元素所属类的构造函数 二、字符串 2.1字符数组（C风格） 2.1.1字符型数据 2.1.2字符数据的输入输出 2.1.3字符数组 2.2string 类 2.2.1常用...
字符串操作
陕西师范大学 人工智能 周一卓 的博客
03-29 3130
字符串操作1.题目2.分析3.代码4.总结5.更新日志 1.题目 题目链接 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 131072K，其他语言262144K 64bit IO Format: %lld 题目描述 给定长度为n的只有小写字母的字符串s，进行m次操作，每次将[l,r]范围内所有c1字符改成c2，输出操作完的字符串 输入描述: 第一行两个数n,m 第二行一个字符串s 之后m行，每行两个数l r两个字符c1 c2 输出描述: 输出一行一个字符串 示例1 输入 5 3 wxh
蓝桥杯练习-3.6
qq_52633682的博客
03-07 846
蓝桥杯练习-3.6 代码练习 完美的代价 问题描述 回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。 　　交换的定义是：交换两个相邻的字符 　　例如mamad 　　第一次交换 ad : mamda 　　第二次交换 md : madma 　　第三次交换 ma : madam (回文！完美！) 输入格式 第一行是一个整数N，表示接下来的字符串的长度(N <= 8000) 　　第二
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CandyDingDing

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值