代码随想录--字符串--替换数字

题目

给定一个字符串 s，它包含小写字母和数字字符，请编写一个函数，将字符串中的字母字符保持不变，而将每个数字字符替换为number。

例如，对于输入字符串 “a1b2c3”，函数应该将其转换为 “anumberbnumbercnumber”。

对于输入字符串 “a5b”，函数应该将其转换为 “anumberb”

输入：一个字符串 s,s 仅包含小写字母和数字字符。

输出：打印一个新的字符串，其中每个数字字符都被替换为了number

样例输入：a1b2c3

样例输出：anumberbnumbercnumber

数据范围：1 <= s.length < 10000。

思路

如果想把这道题目做到极致，就不要只用额外的辅助空间了！ （不过使用Java刷题的录友，一定要使用辅助空间，因为Java里的string不能修改）

首先扩充数组到每个数字字符替换成 “number” 之后的大小。

例如 字符串 “a5b” 的长度为3，那么 将 数字字符变成字符串 “number” 之后的字符串为 “anumberb” 长度为 8。

如图：
然后从后向前替换数字字符，也就是双指针法，过程如下：i指向新长度的末尾，j指向旧长度的末尾。

有同学问了，为什么要从后向前填充，从前向后填充不行么？

从前向后填充就是O(n^2)的算法了，因为每次添加元素都要将添加元素之后的所有元素整体向后移动。

其实很多数组填充类的问题，其做法都是先预先给数组扩容带填充后的大小，然后在从后向前进行操作。

这么做有两个好处：

不用申请新数组。
从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

C++代码如下：

#include
using namespace std;
int main() {
string s;
while (cin >> s) {
int sOldIndex = s.size() - 1;
int count = 0; // 统计数字的个数
for (int i = 0; i < s.size(); i++) {
if (s[i] >= ‘0’ && s[i] <= ‘9’) {
count++;
}
}
// 扩充字符串s的大小，也就是将每个数字替换成"number"之后的大小
s.resize(s.size() + count * 5);
int sNewIndex = s.size() - 1;
// 从后往前将数字替换为"number"
while (sOldIndex >= 0) {
if (s[sOldIndex] >= ‘0’ && s[sOldIndex] <= ‘9’) {
s[sNewIndex–] = ‘r’;
s[sNewIndex–] = ‘e’;
s[sNewIndex–] = ‘b’;
s[sNewIndex–] = ‘m’;
s[sNewIndex–] = ‘u’;
s[sNewIndex–] = ‘n’;
} else {
s[sNewIndex–] = s[sOldIndex];
}
sOldIndex–;
}
cout << s << endl;
}
}

时间复杂度：O(n)
空间复杂度：O(1)

拓展

这里也给大家拓展一下字符串和数组有什么差别，

字符串是若干字符组成的有限序列，也可以理解为是一个字符数组，但是很多语言对字符串做了特殊的规定，接下来我来说一说C/C++中的字符串。

在C语言中，把一个字符串存入一个数组时，也把结束符 '\0’存入数组，并以此作为该字符串是否结束的标志。

例如这段代码：

char a[5] = “asd”;
for (int i = 0; a[i] != ‘\0’; i++) {
}

在C++中，提供一个string类，string类会提供 size接口，可以用来判断string类字符串是否结束，就不用’\0’来判断是否结束。

例如这段代码:

string a = “asd”;
for (int i = 0; i < a.size(); i++) {
}

那么vector< char > 和 string 又有什么区别呢？

其实在基本操作上没有区别，但是 string提供更多的字符串处理的相关接口，例如string 重载了+，而vector却没有。

所以想处理字符串，我们还是会定义一个string类型。

Java

解法一

import java.util.Scanner;

public class Main {

public static String replaceNumber(String s) {
    int count = 0; // 统计数字的个数
    int sOldSize = s.length();
    for (int i = 0; i < s.length(); i++) {
        if(Character.isDigit(s.charAt(i))){
            count++;
        }
    }

s.charAt(i)：charAt 是 String 类的一个方法，用于返回字符串中指定位置的字符。在这里，i 是一个整数，表示字符在字符串中的位置，注意索引是从0开始的。

Character.isDigit(…)：这是Java中的一个静态方法，用于判断给定的字符是否是一个十进制数字。Character 类提供了多种用于字符分类和操作的方法，isDigit 就是其中之一。它接收一个 char 类型的参数，如果参数是一个十进制数字（即字符的Unicode值在 ‘0’ 到 ‘9’ 之间），则返回 true；否则返回 false。

    // 扩充字符串s的大小，也就是每个空格替换成"number"之后的大小
    char[] newS = new char[s.length() + count * 5];
    int sNewSize = newS.length;
    // 将旧字符串的内容填入新数组
    System.arraycopy(s.toCharArray(), 0, newS, 0, sOldSize);

System.arraycopy 是Java中的一个原生方法，用于高效地将一个数组中的元素复制到另一个数组中。它有五个参数：

src：源数组，即要从中复制元素的数组。
srcPos：源数组中的起始位置，即从哪个索引开始复制元素。
dest：目标数组，即要将元素复制到的数组。
destPos：目标数组中的起始位置，即从哪个索引开始放置复制过来的元素。
length：要复制的元素数量。
    // 从后先前将空格替换为"number"
    for (int i = sNewSize - 1, j = sOldSize - 1; j < i; j--, i--) {
        if (!Character.isDigit(newS[j])) {
            newS[i] = newS[j];
        } else {
            newS[i] = 'r';
            newS[i - 1] = 'e';
            newS[i - 2] = 'b';
            newS[i - 3] = 'm';
            newS[i - 4] = 'u';
            newS[i - 5] = 'n';
            i -= 5;
        }
    }
    return new String(newS);
};
public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    String s = scanner.next();
    System.out.println(replaceNumber(s));
    scanner.close();
}

}

解法二

// 为了还原题目本意，先把原数组复制到扩展长度后的新数组，然后不再使用原数组、原地对新数组进行操作。
import java.util.*;

public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
int len = s.length();
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) >= 0 && s.charAt(i) <= ‘9’) {
len += 5;
}
}

    char[] ret = new char[len];
    for (int i = 0; i < s.length(); i++) {
        ret[i] = s.charAt(i);
    }
    for (int i = s.length() - 1, j = len - 1; i >= 0; i--) {
        if ('0' <= ret[i] && ret[i] <= '9') {
            ret[j--] = 'r';
            ret[j--] = 'e';
            ret[j--] = 'b';
            ret[j--] = 'm';
            ret[j--] = 'u';
            ret[j--] = 'n';
        } else {
            ret[j--] = ret[i];
        }
    }
    System.out.println(ret);
}

}